diff --git a/docs/gallery/assets/hay-bale-hero.webp b/docs/gallery/assets/hay-bale-hero.webp
index 0c6573c..2092fb3 100644
Binary files a/docs/gallery/assets/hay-bale-hero.webp and b/docs/gallery/assets/hay-bale-hero.webp differ
diff --git a/docs/gallery/assets/hitching-post-hero.webp b/docs/gallery/assets/hitching-post-hero.webp
index 2c65ebe..39d5d78 100644
Binary files a/docs/gallery/assets/hitching-post-hero.webp and b/docs/gallery/assets/hitching-post-hero.webp differ
diff --git a/docs/gallery/hay-bale/index.html b/docs/gallery/hay-bale/index.html
index f2ceaa2..cdb2c3d 100644
--- a/docs/gallery/hay-bale/index.html
+++ b/docs/gallery/hay-bale/index.html
@@ -4,18 +4,18 @@
   <meta charset="utf-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1" />
   <title>hay-bale — Examples — Blender Developer Tools</title>
-  <meta name="description" content="A procedural bound hay bale with a bevelled loaf, end nap, and two sisal twine belts through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
+  <meta name="description" content="A procedural bound hay bale with a cinched pillow loaf, end nap, and two sisal twine belts 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/hay-bale/" />
   <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="hay-bale — Examples — Blender Developer Tools" />
-  <meta property="og:description" content="A procedural bound hay bale with a bevelled loaf, end nap, and two sisal twine belts through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
+  <meta property="og:description" content="A procedural bound hay bale with a cinched pillow loaf, end nap, and two sisal twine belts 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/hay-bale/" />
   <meta property="og:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/hay-bale-hero.webp" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="hay-bale — Examples — Blender Developer Tools" />
-  <meta name="twitter:description" content="A procedural bound hay bale with a bevelled loaf, end nap, and two sisal twine belts through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
+  <meta name="twitter:description" content="A procedural bound hay bale with a cinched pillow loaf, end nap, and two sisal twine belts 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/hay-bale-hero.webp" />
   <style>
     /* fonts are deployed by the landing build (docs/fonts/) */
@@ -246,35 +246,37 @@
   </div>
   <header class="hero">
     <h1>hay-bale</h1>
-    <p>A procedural bound hay bale with a bevelled loaf, end nap, and two sisal twine belts through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.</p>
+    <p>A procedural bound hay bale with a cinched pillow loaf, end nap, and two sisal twine belts 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 hay-bale render">
       <img src="../assets/hay-bale-hero.webp" alt="hay-bale 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: 252 tris, two materials with 66 hay and 60 twine faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.916×0.520×0.401 m, LOD ratios in band (5.2 COLLAPSE more aggressive), convex collider 68 tris, non-empty glTF. --skip-decimate exits 9 on the LOD1 ratio budget.</div>
+    <div class="callout"><span class="tag">witnesses</span> Recomputed: 852 tris, two materials with 294 hay and 132 twine faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.920×0.517×0.426 m, zmin 0, hygiene 0, hay-twine BVH gap 0.07 mm, LOD ratios in band, convex collider 78 tris, non-empty glTF. --skip-decimate exits 9 on LOD1; --lift-z exits 16 on grounded zmin.</div>
     <div class="runline">
       <pre id="runCmd">blender --background --python showcase/hay-bale/hay_bale.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 bound straw bale (bevelled loaf, end nap, two sisal twine belts) 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 bound straw bale (cinched pillow loaf, end nap, two square-torus sisal belts with hitch loops) then the shipped pipeline: unique-cell UVs, Cycles high-to-low normal bake, LOD chain, convex collider, Unity glTF export.</p>
 <p>It asserts <strong>budget conformance</strong> of the generated result. It does not witness an API contract. &quot;It rendered without error&quot; is not a check.</p>
-<p><strong>Composes</strong> skills <code>mesh-editing-and-bmesh</code>, <code>bake-high-to-low</code>, <code>depsgraph-and-evaluated-data</code>, <code>engine-export-presets</code>, and snippets <code>bake_normal_high_to_low.py</code>, <code>setup_bake_target_image.py</code>, <code>lod_chain.py</code> / <code>decimate_to_budget.py</code>, <code>convex_hull_collider.py</code>, <code>export_preset_unity.py</code> (helpers copied, not imported as a package).</p>
+<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: 0.90 × 0.48 × 0.38 m core loaf; outer AABB includes cinch bulge and belts.</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 | 220–290 | 252 / 252 / 252 | | LOD1 ratio | 0.32–0.62 of base | 0.5000 / 0.5000 / 0.4683 | | LOD2 ratio | 0.10–0.35 of base | 0.2143 / 0.2143 / 0.1429 | | Materials | exactly 2 distinct, ≥24 hay, ≥24 twine | 2 slots, 66 hay, 60 twine | | UVs | in <code>0..1</code>, AABB overlap ≤ 1e-5 | in range, overlap 0 | | Outer AABB | (0.916, 0.520, 0.401) m ± 0.01 | (0.9160, 0.5200, 0.4010), zmin 0 | | Collider tris | ≤ 120 | 68 | | Export | written, size &gt; 0 | 25944 / 25944 / 25936 bytes |</p>
-<p>DECIMATE COLLAPSE triangle counts are <strong>not</strong> identical across series — 5.2.1 is more aggressive on both LOD ratios. 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 | 750–1100 | 852 / 852 / 852 | | LOD1 ratio | 0.32–0.62 of base | 0.5000 / 0.5000 / 0.5000 | | LOD2 ratio | 0.10–0.35 of base | 0.2183 / 0.2183 / 0.2183 | | Materials | exactly 2 distinct, ≥24 hay, ≥24 twine | 2 slots, 294 hay, 132 twine | | UVs | in <code>0..1</code>, AABB overlap ≤ 1e-5 | in range, overlap 0 | | Outer AABB | (0.920, 0.517, 0.426) m ± 0.01 | (0.9199, 0.5170, 0.4257) | | Grounded zmin | within 1e-4 of 0 | 0 / 0 / 0 | | Hygiene | loose/nonman/zero-area/doubles/ngons = 0 | 0 / 0 / 0 | | Hay–twine gap | BVH surface &lt; 0.008 m | 0.00007 / 0.00007 / 0.00007 | | Collider tris | ≤ 400 | 78 | | Export | written, size &gt; 0 | 70720 / 70720 / 70712 bytes |</p>
+<p>DECIMATE COLLAPSE triangle counts are <strong>not</strong> identical across series — the gate is a ratio band, not an exact count. Bake pixels are stochastic; the gate is <code>has_data</code> plus operator <code>FINISHED</code>, not byte-identity. Construction uses no RNG. Export byte counts differ by 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. <code>--lift-z</code> raises the mesh 5 cm so the grounded-zmin hygiene budget fails and exit 16 fires.</p>
 <h2>Run</h2>
 <pre><code>blender --background --python hay_bale.py --
 blender --background --python hay_bale.py -- --skip-decimate
+blender --background --python hay_bale.py -- --lift-z
 blender --background --python hay_bale.py -- --output bale.png</code></pre>
-<p>Smoke does not pass <code>--output</code> or <code>--skip-decimate</code>.</p>
+<p>Smoke does not pass <code>--output</code>, <code>--skip-decimate</code>, or <code>--lift-z</code>.</p>
 <h2>Exit codes</h2>
 <p>File-local. <code>9</code> is a valid check code. <code>10</code> is reserved for <code>gallery_framing.check_framing</code> on the <code>--output</code> path.</p>
-<p>| Code | Meaning | | --- | --- | | 0 | Success | | 1 | Uncaught exception (FATAL wrapper) | | 2 | argparse / usage | | 3 | Mesh did not build / no UV layer | | 4 | Base triangle count outside range | | 5 | Material count ≠ 2 distinct slots, or hay/twine faces missing | | 6 | UVs outside 0..1 | | 7 | UV AABB overlap above tolerance | | 8 | World AABB off declared outer size | | 9 | LOD ratio band (<code>--skip-decimate</code> lands here) | | 10 | Framing gate (render path only) | | 11 | Collider triangle count above ceiling | | 12 | Bake did not finish or image has no data | | 13 | Export file missing or empty | | 14 | <code>--output</code> produced no file |</p>
+<p>| Code | Meaning | | --- | --- | | 0 | Success | | 1 | Uncaught exception (FATAL wrapper) | | 2 | argparse / usage | | 3 | Mesh did not build / no UV layer | | 4 | Base triangle count outside range | | 5 | Material count ≠ 2 distinct slots, or hay/twine 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: loose verts/edges, non-manifold, zero-area, doubles, or n-gons | | 16 | Grounded zmin (<code>--lift-z</code> lands here) | | 17 | Hay–twine BVH gap above 8 mm |</p>
     </section>
     <section class="detail-section src">
       <h2>Source</h2>
@@ -290,7 +292,8 @@ <h2>Source</h2>
 
 Budgets are declared below and recomputed from the generated result.
 They are not API-contract witnesses. ``--skip-decimate`` skips the LOD
-DECIMATE stage so the LOD-ratio budget fails.
+DECIMATE stage so the LOD-ratio budget fails. ``--lift-z`` raises the
+mesh so the grounded-zmin hygiene budget fails.
 
 No RNG. Construction is closed-form. DECIMATE COLLAPSE triangle counts
 are not byte-identical across Blender versions — the LOD gate is a
@@ -298,6 +301,7 @@ <h2>Source</h2>
 
     blender --background --python hay_bale.py --
     blender --background --python hay_bale.py -- --skip-decimate
+    blender --background --python hay_bale.py -- --lift-z
     blender --background --python hay_bale.py -- --output bale.png
 &quot;&quot;&quot;</span>
 <span class="k">import</span> argparse
@@ -310,6 +314,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
 
 <span class="c"># Showcase lives at repo-root/showcase/, not under examples/. The framing</span>
 <span class="c"># helper is the repo&#x27;s only shared import and lives next to the examples;</span>
@@ -324,15 +329,24 @@ <h2>Source</h2>
 BALE_X = <span class="n">0.90</span>
 BALE_Y = <span class="n">0.48</span>
 BALE_Z = <span class="n">0.38</span>
-TWINE_T = <span class="n">0.014</span>
-TWINE_W = <span class="n">0.026</span>
-TWINE_PAD = <span class="n">0.006</span>
+TWINE_T = <span class="n">0.012</span>
+TWINE_W = <span class="n">0.028</span>
+TWINE_EMBED = <span class="n">0.003</span>
+BELT_XS = (-<span class="n">0.225</span>, <span class="n">0.225</span>)
+LOAF_CUTS = <span class="n">4</span>
+BULGE = <span class="n">0.055</span>
+RIDGE_AMP = <span class="n">0.007</span>
 BBOX_TOL = <span class="n">0.01</span>
 <span class="c"># Fitted after locking geometry. Recomputed from bound_box.</span>
-OUTER_SIZE = (<span class="n">0.916</span>, <span class="n">0.520</span>, <span class="n">0.401</span>)
-
-BASE_TRIS_MIN = <span class="n">220</span>
-BASE_TRIS_MAX = <span class="n">290</span>
+OUTER_SIZE = (<span class="n">0.920</span>, <span class="n">0.517</span>, <span class="n">0.426</span>)
+
+BASE_TRIS_MIN = <span class="n">750</span>
+BASE_TRIS_MAX = <span class="n">1100</span>
+ZMIN_EPS = <span class="n">1e-4</span>
+DOUBLES_EPS = <span class="n">1e-5</span>
+AREA_EPS = <span class="n">1e-10</span>
+GAP_MAX = <span class="n">0.008</span>
+LIFT_Z = <span class="n">0.05</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>
@@ -342,7 +356,7 @@ <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">120</span>
+COLLIDER_TRIS_MAX = <span class="n">400</span>
 BAKE_RES = <span class="n">256</span>
 CAGE_EXTRUSION = <span class="n">0.04</span>
 HAY_FACES_MIN = <span class="n">24</span>
@@ -392,6 +406,150 @@ <h2>Source</h2>
     <span class="k">return</span> verts
 
 
+<span class="k">def</span> add_rim(bm, loc, major, minor, mat_idx, euler=(<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>), n_major=<span class="n">12</span>, n_minor=<span class="n">6</span>):
+    rings = []
+    <span class="k">for</span> i <span class="k">in</span> range(n_major):
+        u = i * (<span class="n">2.0</span> * math.pi / n_major)
+        ring = []
+        <span class="k">for</span> j <span class="k">in</span> range(n_minor):
+            v = j * (<span class="n">2.0</span> * math.pi / n_minor)
+            ring.append(bm.verts.new((
+                (major + minor * math.cos(v)) * math.cos(u),
+                (major + minor * math.cos(v)) * math.sin(u),
+                minor * math.sin(v),
+            )))
+        rings.append(ring)
+    bm.verts.ensure_lookup_table()
+    <span class="k">for</span> i <span class="k">in</span> range(n_major):
+        i2 = (i + <span class="n">1</span>) % n_major
+        <span class="k">for</span> j <span class="k">in</span> range(n_minor):
+            j2 = (j + <span class="n">1</span>) % n_minor
+            face = bm.faces.new((rings[i][j], rings[i2][j], rings[i2][j2], rings[i][j2]))
+            face.material_index = mat_idx
+    verts = [v <span class="k">for</span> ring <span class="k">in</span> rings <span class="k">for</span> v <span class="k">in</span> ring]
+    rot = Euler(euler).to_matrix()
+    origin = Vector(loc)
+    <span class="k">for</span> v <span class="k">in</span> verts:
+        v.co = rot @ v.co + origin
+    <span class="k">return</span> verts
+
+
+<span class="k">def</span> add_square_wrap(bm, x, y_half, z_lo, z_hi, t, w, mat_idx):
+    <span class="s">&quot;&quot;&quot;Closed rectangular belt in YZ, extruded along X. One manifold torus.&quot;&quot;&quot;</span>
+    x0 = x - w * <span class="n">0.5</span>
+    x1 = x + w * <span class="n">0.5</span>
+    inner = (
+        (y_half, z_lo),
+        (y_half, z_hi),
+        (-y_half, z_hi),
+        (-y_half, z_lo),
+    )
+    outer = (
+        (y_half + t, z_lo - t),
+        (y_half + t, z_hi + t),
+        (-y_half - t, z_hi + t),
+        (-y_half - t, z_lo - t),
+    )
+
+    <span class="k">def</span> ring(xc, pts):
+        <span class="k">return</span> [bm.verts.new((xc, p[<span class="n">0</span>], p[<span class="n">1</span>])) <span class="k">for</span> p <span class="k">in</span> pts]
+
+    i0 = ring(x0, inner)
+    o0 = ring(x0, outer)
+    i1 = ring(x1, inner)
+    o1 = ring(x1, outer)
+
+    <span class="k">def</span> quad(a, b, c, d):
+        face = bm.faces.new((a, b, c, d))
+        face.material_index = mat_idx
+        <span class="k">return</span> face
+
+    <span class="k">for</span> k <span class="k">in</span> range(<span class="n">4</span>):
+        n = (k + <span class="n">1</span>) % <span class="n">4</span>
+        quad(i0[k], i1[k], i1[n], i0[n])
+        quad(o0[k], o0[n], o1[n], o1[k])
+        quad(i0[k], i0[n], o0[n], o0[k])
+        quad(i1[k], o1[k], o1[n], i1[n])
+
+
+<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):
+    <span class="c"># Combinatorics match examples/mesh-hygiene-audit.audit (copied, not imported).</span>
+    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>)
+    areas = [face_area(me, p) <span class="k">for</span> p <span class="k">in</span> me.polygons]
+    zero_area = sum(<span class="n">1</span> <span class="k">for</span> a <span class="k">in</span> areas <span class="k">if</span> a &lt;= AREA_EPS)
+    bm = bmesh.new()
+    <span class="k">try</span>:
+        bm.from_mesh(me)
+        bm.verts.ensure_lookup_table()
+        bm.edges.ensure_lookup_table()
+        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> min_mat_distance(me, ia, ib):
+    <span class="s">&quot;&quot;&quot;Closest surface distance between two material islands via BVH.
+
+    Vert-vert distance is the wrong metric for a 4-corner strap: the inner
+    face has no mid-edge verts, so a cinched belt still reports ~TWINE_W/2.
+    &quot;&quot;&quot;</span>
+    bm_a = bmesh.new()
+    bm_b = bmesh.new()
+    <span class="k">try</span>:
+        bm_a.from_mesh(me)
+        bm_b.from_mesh(me)
+        bm_a.faces.ensure_lookup_table()
+        bm_b.faces.ensure_lookup_table()
+        drop_a = [f <span class="k">for</span> f <span class="k">in</span> bm_a.faces <span class="k">if</span> f.material_index != ia]
+        drop_b = [f <span class="k">for</span> f <span class="k">in</span> bm_b.faces <span class="k">if</span> f.material_index != ib]
+        <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> src <span class="k">in</span> list(bm_a.verts) + list(bm_a.faces):
+            co = src.co <span class="k">if</span> hasattr(src, <span class="s">&quot;co&quot;</span>) <span class="k">else</span> src.calc_center_median()
+            hit = tree.find_nearest(co)
+            <span class="k">if</span> hit[<span class="n">0</span>] <span class="k">is</span> <span class="k">None</span>:
+                <span class="k">continue</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> pack_uvs(bm, margin=<span class="n">0.08</span>):
     uv = bm.loops.layers.uv.new(<span class="s">&quot;UVMap&quot;</span>)
     faces = list(bm.faces)
@@ -435,6 +593,29 @@ <h2>Source</h2>
             )
 
 
+<span class="k">def</span> _shape_loaf(verts):
+    hx = BALE_X * <span class="n">0.5</span>
+    hy = BALE_Y * <span class="n">0.5</span>
+    hz = BALE_Z * <span class="n">0.5</span>
+    zc = BALE_Z * <span class="n">0.5</span>
+    <span class="k">for</span> v <span class="k">in</span> verts:
+        x, y, z = v.co.x, v.co.y, v.co.z
+        nx = max(-<span class="n">1.0</span>, min(<span class="n">1.0</span>, x / hx))
+        ny = max(-<span class="n">1.0</span>, min(<span class="n">1.0</span>, y / hy))
+        nz = max(-<span class="n">1.0</span>, min(<span class="n">1.0</span>, (z - zc) / hz))
+        pillow = <span class="n">1.0</span> + BULGE * (<span class="n">1.0</span> - nx * nx)
+        v.co.y = y * pillow
+        v.co.z = zc + (z - zc) * pillow
+        <span class="c"># Longitudinal straw ridges on the long faces; closed-form, no RNG.</span>
+        ridge = RIDGE_AMP * math.sin(x * <span class="n">24.0</span>) * (<span class="n">0.35</span> + <span class="n">0.65</span> * abs(ny))
+        v.co.y += ridge
+        v.co.z += <span class="n">0.55</span> * RIDGE_AMP * math.sin(x * <span class="n">19.0</span> + <span class="n">0.7</span>) * (<span class="n">0.35</span> + <span class="n">0.65</span> * abs(nz))
+        <span class="c"># End-grain nap: bite the ±X faces instead of gluing on extra slabs.</span>
+        <span class="k">if</span> abs(nx) &gt; <span class="n">0.82</span>:
+            rr = math.hypot(v.co.y / (hy * pillow), (v.co.z - zc) / (hz * pillow))
+            v.co.x += math.copysign(<span class="n">0.010</span> * math.sin(rr * <span class="n">14.0</span>), x)
+
+
 <span class="k">def</span> build_bale_mesh(name, bevel_offset, bevel_segments):
     bm = bmesh.new()
     hay_verts = []
@@ -448,60 +629,62 @@ <h2>Source</h2>
                 HAY_IDX,
             )
         )
+        bmesh.ops.subdivide_edges(
+            bm,
+            edges=list({e <span class="k">for</span> v <span class="k">in</span> hay_verts <span class="k">for</span> e <span class="k">in</span> v.link_edges}),
+            cuts=LOAF_CUTS,
+            use_grid_fill=<span class="k">True</span>,
+        )
+        hay_verts = [v <span class="k">for</span> v <span class="k">in</span> bm.verts]
+        _shape_loaf(hay_verts)
         <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> hay_verts <span class="k">for</span> e <span class="k">in</span> v.link_edges <span class="k">if</span> v.is_valid})
-            <span class="k">if</span> edges:
-                bmesh.ops.bevel(
-                    bm,
-                    geom=edges,
-                    offset=bevel_offset,
-                    segments=bevel_segments,
-                    profile=<span class="n">0.5</span>,
-                    affect=<span class="s">&quot;EDGES&quot;</span>,
-                    clamp_overlap=<span class="k">True</span>,
-                )
-
-        hx = BALE_X / <span class="n">2.0</span>
-        hy = BALE_Y / <span class="n">2.0</span>
-        <span class="k">for</span> sign <span class="k">in</span> (-<span class="n">1.0</span>, <span class="n">1.0</span>):
-            add_box(
+            bm.edges.ensure_lookup_table()
+            edges = []
+            <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">2</span>:
+                    <span class="k">continue</span>
+                <span class="k">if</span> e.calc_face_angle() &gt; math.radians(<span class="n">50.0</span>):
+                    edges.append(e)
+            <span class="k">if</span> <span class="k">not</span> edges:
+                edges = list(bm.edges)
+            bmesh.ops.bevel(
                 bm,
-                (sign * (hx + <span class="n">0.002</span>), <span class="n">0.0</span>, BALE_Z / <span class="n">2.0</span>),
-                (<span class="n">0.012</span>, BALE_Y * <span class="n">0.98</span>, BALE_Z * <span class="n">0.96</span>),
-                HAY_IDX,
+                geom=edges,
+                offset=bevel_offset,
+                segments=bevel_segments,
+                profile=<span class="n">0.45</span>,
+                affect=<span class="s">&quot;EDGES&quot;</span>,
+                clamp_overlap=<span class="k">True</span>,
             )
 
+        hay_now = [v <span class="k">for</span> v <span class="k">in</span> bm.verts]
         before = set(bm.faces)
-        <span class="k">for</span> x <span class="k">in</span> (-<span class="n">0.22</span>, <span class="n">0.22</span>):
-            wrap_y = BALE_Y + <span class="n">2.0</span> * TWINE_PAD + TWINE_T
-            wrap_z = BALE_Z + <span class="n">2.0</span> * TWINE_PAD
-            add_box(bm, (x, <span class="n">0.0</span>, TWINE_T / <span class="n">2.0</span>), (TWINE_W, wrap_y, TWINE_T), TWINE_IDX)
-            add_box(
+        <span class="k">for</span> x <span class="k">in</span> BELT_XS:
+            near = [v <span class="k">for</span> v <span class="k">in</span> hay_now <span class="k">if</span> abs(v.co.x - x) &lt;= <span class="n">0.08</span>]
+            <span class="k">if</span> len(near) &lt; <span class="n">8</span>:
+                near = hay_now
+            y_max = max(abs(v.co.y) <span class="k">for</span> v <span class="k">in</span> near)
+            z_min = min(v.co.z <span class="k">for</span> v <span class="k">in</span> near)
+            z_max = max(v.co.z <span class="k">for</span> v <span class="k">in</span> near)
+            <span class="c"># Sit the belt in the ridge troughs so it cinches the peaks.</span>
+            y_half = y_max - RIDGE_AMP - TWINE_EMBED
+            z_lo = z_min + RIDGE_AMP + TWINE_EMBED
+            z_hi = z_max - RIDGE_AMP - TWINE_EMBED
+            add_square_wrap(bm, x, y_half, z_lo, z_hi, TWINE_T, TWINE_W, TWINE_IDX)
+            add_rim(
                 bm,
-                (x, <span class="n">0.0</span>, BALE_Z + TWINE_PAD - TWINE_T / <span class="n">2.0</span>),
-                (TWINE_W, wrap_y, TWINE_T),
-                TWINE_IDX,
-            )
-            add_box(
-                bm,
-                (x, hy + TWINE_PAD + TWINE_T / <span class="n">2.0</span>, BALE_Z / <span class="n">2.0</span> + <span class="n">0.004</span>),
-                (TWINE_W, TWINE_T, wrap_z),
-                TWINE_IDX,
-            )
-            add_box(
-                bm,
-                (x, -(hy + TWINE_PAD + TWINE_T / <span class="n">2.0</span>), BALE_Z / <span class="n">2.0</span> + <span class="n">0.004</span>),
-                (TWINE_W, TWINE_T, wrap_z),
-                TWINE_IDX,
-            )
-            add_box(
-                bm,
-                (x, <span class="n">0.02</span>, BALE_Z + TWINE_PAD + <span class="n">0.004</span>),
-                (TWINE_W + <span class="n">0.008</span>, <span class="n">0.032</span>, <span class="n">0.018</span>),
+                (x, <span class="n">0.0</span>, z_hi + TWINE_T),
+                <span class="n">0.014</span>,
+                <span class="n">0.007</span>,
                 TWINE_IDX,
+                euler=(math.pi / <span class="n">2.0</span>, <span class="n">0.0</span>, math.pi / <span class="n">2.0</span>),
+                n_major=<span class="n">10</span>,
+                n_minor=<span class="n">5</span>,
             )
         twine_faces.update(set(bm.faces) - before)
 
+        bmesh.ops.remove_doubles(bm, verts=list(bm.verts), dist=DOUBLES_EPS)
+
         zs = [v.co.z <span class="k">for</span> v <span class="k">in</span> bm.verts]
         zmin = min(zs)
         xs = [v.co.x <span class="k">for</span> v <span class="k">in</span> bm.verts]
@@ -537,13 +720,33 @@ <h2>Source</h2>
     <span class="k">return</span> obj
 
 
-<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">8.0</span>
+        tex.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.55</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>])
+        rmix = nt.nodes.new(<span class="s">&quot;ShaderNodeMix&quot;</span>)
+        rmix.data_type = <span class="s">&quot;FLOAT&quot;</span>
+        rmix.inputs[<span class="s">&quot;A&quot;</span>].default_value = roughness
+        rmix.inputs[<span class="s">&quot;B&quot;</span>].default_value = min(<span class="n">1.0</span>, roughness + <span class="n">0.18</span>)
+        rfac = rmix.inputs.get(<span class="s">&quot;Factor&quot;</span>) <span class="k">or</span> rmix.inputs.get(<span class="s">&quot;Fac&quot;</span>)
+        nt.links.new(tex.outputs[<span class="s">&quot;Fac&quot;</span>], rfac)
+        nt.links.new(rmix.outputs[<span class="s">&quot;Result&quot;</span>], bsdf.inputs[<span class="s">&quot;Roughness&quot;</span>])
     <span class="k">return</span> mat
 
 
@@ -682,14 +885,32 @@ <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>):
     bpy.ops.wm.read_factory_settings(use_empty=<span class="k">True</span>)
-    low = build_bale_mesh(<span class="s">&quot;BaleLow&quot;</span>, bevel_offset=<span class="n">0.012</span>, bevel_segments=<span class="n">2</span>)
-    high = build_bale_mesh(<span class="s">&quot;BaleHigh&quot;</span>, bevel_offset=<span class="n">0.012</span>, bevel_segments=<span class="n">4</span>)
-    hay = principled(<span class="s">&quot;BaleHay&quot;</span>, (<span class="n">0.72</span>, <span class="n">0.55</span>, <span class="n">0.18</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.84</span>)
-    twine = principled(<span class="s">&quot;BaleTwine&quot;</span>, (<span class="n">0.20</span>, <span class="n">0.14</span>, <span class="n">0.07</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.52</span>)
+    low = build_bale_mesh(<span class="s">&quot;BaleLow&quot;</span>, bevel_offset=<span class="n">0.016</span>, bevel_segments=<span class="n">2</span>)
+    high = build_bale_mesh(<span class="s">&quot;BaleHigh&quot;</span>, bevel_offset=<span class="n">0.016</span>, bevel_segments=<span class="n">4</span>)
+    hay = principled(
+        <span class="s">&quot;BaleHay&quot;</span>,
+        (<span class="n">0.66</span>, <span class="n">0.52</span>, <span class="n">0.18</span>, <span class="n">1.0</span>),
+        <span class="n">0.0</span>,
+        <span class="n">0.78</span>,
+        noise_scale=<span class="n">22.0</span>,
+        wear=(<span class="n">0.48</span>, <span class="n">0.36</span>, <span class="n">0.10</span>, <span class="n">1.0</span>),
+    )
+    twine = principled(
+        <span class="s">&quot;BaleTwine&quot;</span>,
+        (<span class="n">0.22</span>, <span class="n">0.16</span>, <span class="n">0.08</span>, <span class="n">1.0</span>),
+        <span class="n">0.0</span>,
+        <span class="n">0.58</span>,
+        noise_scale=<span class="n">14.0</span>,
+        wear=(<span class="n">0.14</span>, <span class="n">0.10</span>, <span class="n">0.05</span>, <span class="n">1.0</span>),
+    )
     assign_slots(low, hay, twine)
     assign_slots(high, hay, twine)
+    <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;hay bale 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>
@@ -750,10 +971,18 @@ <h2>Source</h2>
         <span class="s">f&quot;</span><span class="s">measured bbox=(</span>{size_x:<span class="s">.4f</span>}<span class="s">,</span>{size_y:<span class="s">.4f</span>}<span class="s">,</span>{size_z:<span class="s">.4f</span>}<span class="s">) </span><span class="s">&quot;</span>
         <span class="s">f&quot;</span><span class="s">outer=</span>{OUTER_SIZE}<span class="s"> zmin=</span>{bb[<span class="n">2</span>]:<span class="s">.4f</span>}<span class="s">&quot;</span>
     )
+    hyg = hygiene_audit(low.data)
+    gap = min_mat_distance(low.data, TWINE_IDX, HAY_IDX)
     print(
         <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"> euler=</span>{hyg[<span class="s">&#x27;euler&#x27;</span>]}<span class="s">&quot;</span>
+    )
+    print(<span class="s">f&quot;</span><span class="s">measured hay_twine_gap=</span>{gap:<span class="s">.5f</span>}<span class="s"> zmin=</span>{bb[<span class="n">2</span>]:<span class="s">.6f</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(
@@ -818,6 +1047,31 @@ <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">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">&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">if</span> abs(bb[<span class="n">2</span>]) &gt; ZMIN_EPS:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">zmin </span>{bb[<span class="n">2</span>]:<span class="s">.6f</span>}<span class="s"> not within </span>{ZMIN_EPS}<span class="s"> of 0 </span><span class="s">&quot;</span>
+            <span class="s">&quot;(--lift-z is the designed fail)&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> gap &gt; GAP_MAX:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">hay-twine gap </span>{gap:<span class="s">.5f</span>}<span class="s"> &gt; </span>{GAP_MAX}<span class="s"> (twine must cinch the loaf)</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">return</span> <span class="n">0</span>, low, high, hay, tex, collider
 
 
@@ -935,9 +1189,14 @@ <h2>Source</h2>
         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;--lift-z&quot;</span>,
+        action=<span class="s">&quot;store_true&quot;</span>,
+        help=<span class="s">&quot;falsification: lift the mesh so zmin fails the grounded budget&quot;</span>,
+    )
     args = p.parse_args(argv)
 
-    code, low, _high, hay, tex, _col = check(args.skip_decimate)
+    code, low, _high, hay, tex, _col = check(args.skip_decimate, lift_z=args.lift_z)
     <span class="k">if</span> code:
         <span class="k">return</span> code
     <span class="k">if</span> args.output:
diff --git a/docs/gallery/hitching-post/index.html b/docs/gallery/hitching-post/index.html
index 701d65f..0aab17a 100644
--- a/docs/gallery/hitching-post/index.html
+++ b/docs/gallery/hitching-post/index.html
@@ -4,18 +4,18 @@
   <meta charset="utf-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1" />
   <title>hitching-post — Examples — Blender Developer Tools</title>
-  <meta name="description" content="A procedural hitching post through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
+  <meta name="description" content="A procedural hitching post (corner-aligned cap, stub-and-tenon arm, collar shoe, eye-threaded rings) 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/hitching-post/" />
   <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="hitching-post — Examples — Blender Developer Tools" />
-  <meta property="og:description" content="A procedural hitching post through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
+  <meta property="og:description" content="A procedural hitching post (corner-aligned cap, stub-and-tenon arm, collar shoe, eye-threaded rings) 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/hitching-post/" />
   <meta property="og:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/hitching-post-hero.webp" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="hitching-post — Examples — Blender Developer Tools" />
-  <meta name="twitter:description" content="A procedural hitching post through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
+  <meta name="twitter:description" content="A procedural hitching post (corner-aligned cap, stub-and-tenon arm, collar shoe, eye-threaded rings) 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/hitching-post-hero.webp" />
   <style>
     /* fonts are deployed by the landing build (docs/fonts/) */
@@ -246,35 +246,37 @@
   </div>
   <header class="hero">
     <h1>hitching-post</h1>
-    <p>A procedural hitching post through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.</p>
+    <p>A procedural hitching post (corner-aligned cap, stub-and-tenon arm, collar shoe, eye-threaded rings) 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 hitching-post render">
       <img src="../assets/hitching-post-hero.webp" alt="hitching-post 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: 848 tris, two materials with 262 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.460×0.194×1.260 m, LOD ratios in band (5.2 COLLAPSE more aggressive on LOD2), convex collider 144 tris, non-empty glTF. --skip-decimate exits 9 on the LOD1 ratio budget.</div>
+    <div class="callout"><span class="tag">witnesses</span> Recomputed: 1598 tris, two materials with 269 wood and 532 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.460×0.191×1.258 m, zmin 0, hygiene 0, wood-metal BVH gap 0.45 mm, LOD ratios in band, convex collider 78 tris, non-empty glTF. --skip-decimate exits 9 on LOD1; --lift-z exits 16 on grounded zmin.</div>
     <div class="runline">
       <pre id="runCmd">blender --background --python showcase/hitching-post/hitching_post.py --</pre>
       <button class="copy-btn" id="copyRun" type="button">Copy</button>
     </div>
     <section class="detail-section md">
-<p>A showcase piece, not an example. Procedural timber hitching post (square post, pyramidal cap, cross-arm, iron shoe, bands, and two hitching rings) then the shipped pipeline: unique-cell UVs, Cycles high-to-low normal bake, LOD chain, convex collider, Unity glTF export.</p>
+<p>A showcase piece, not an example. Procedural timber hitching post (square post, pyramid cap on the post corners, stub-and-tenon cross-arm, iron collar shoe and bands, eye-threaded hitching rings) then the shipped pipeline: unique-cell UVs, Cycles high-to-low normal bake, LOD chain, convex collider, Unity glTF export.</p>
 <p>It asserts <strong>budget conformance</strong> of the generated result. It does not witness an API contract. &quot;It rendered without error&quot; is not a check.</p>
-<p><strong>Composes</strong> skills <code>mesh-editing-and-bmesh</code>, <code>bake-high-to-low</code>, <code>depsgraph-and-evaluated-data</code>, <code>engine-export-presets</code>, and snippets <code>bake_normal_high_to_low.py</code>, <code>setup_bake_target_image.py</code>, <code>lod_chain.py</code> / <code>decimate_to_budget.py</code>, <code>convex_hull_collider.py</code>, <code>export_preset_unity.py</code> (helpers copied, not imported as a package).</p>
+<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: 0.125 m square post, 1.16 m timber plus 0.10 m cap; cross-arm 0.46 m; outer AABB 0.460 × 0.191 × 1.258 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 | 780–920 | 848 / 848 / 848 | | LOD1 ratio | 0.32–0.62 of base | 0.5000 / 0.5000 / 0.5000 | | LOD2 ratio | 0.10–0.35 of base | 0.2193 / 0.2193 / 0.1958 | | Materials | exactly 2 distinct, ≥24 metal faces | 2 slots, 262 metal | | UVs | in <code>0..1</code>, AABB overlap ≤ 1e-5 | in range, overlap 0 | | Outer AABB | (0.460, 0.194, 1.260) m ± 0.01 | (0.4600, 0.1943, 1.2600), zmin 0 | | Collider tris | ≤ 180 | 144 | | Export | written, size &gt; 0 | 73164 / 73164 / 73160 bytes |</p>
-<p>DECIMATE COLLAPSE triangle counts are <strong>not</strong> identical across series — 5.2.1 is more aggressive on LOD2. The gate is a ratio band, not an exact count. Bake pixels are stochastic; the gate is <code>has_data</code> plus operator <code>FINISHED</code>, not byte-identity. Construction uses no RNG. Export byte counts differ by 4 B on 5.2.1 (glTF serializer), not a gated axis.</p>
-<p><code>--skip-decimate</code> skips the LOD DECIMATE stage so LOD1 ratio is 1.0 and exit 9 fires. That is the named budget the falsifier violates.</p>
+<p>| Axis | Declared | Measured (4.5.11 / 5.1.2 / 5.2.1) | | --- | --- | --- | | Base triangles | 900–1800 | 1598 / 1598 / 1598 | | LOD1 ratio | 0.32–0.62 of base | 0.4994 / 0.4994 / 0.4994 | | LOD2 ratio | 0.10–0.35 of base | 0.2190 / 0.2190 / 0.2190 | | Materials | exactly 2 distinct, ≥12 wood, ≥24 metal | 2 slots, 269 wood, 532 metal | | UVs | in <code>0..1</code>, AABB overlap ≤ 1e-5 | in range, overlap 0 | | Outer AABB | (0.460, 0.191, 1.258) m ± 0.01 | (0.4600, 0.1912, 1.2580) | | Grounded zmin | within 1e-4 of 0 | 0 / 0 / 0 | | Hygiene | loose/nonman/zero-area/doubles/ngons = 0 | 0 / 0 / 0 | | Wood–metal gap | BVH surface &lt; 0.008 m | 0.00045 / 0.00045 / 0.00045 | | Collider tris | ≤ 280 | 78 | | Export | written, size &gt; 0 | 121496 / 121496 / 121480 bytes |</p>
+<p>DECIMATE COLLAPSE triangle counts are <strong>not</strong> identical across series — the gate is a ratio band, not an exact count. Bake pixels are stochastic; the gate is <code>has_data</code> plus operator <code>FINISHED</code>, not byte-identity. Construction uses no RNG. Export byte counts differ by 16 B on 5.2.1 (glTF serializer), not a gated axis. Euler characteristic is 10 (multi-body: timber, collars, eyes, rings) — not gated to 2.</p>
+<p><code>--skip-decimate</code> skips the LOD DECIMATE stage so LOD1 ratio is 1.0 and exit 9 fires. <code>--lift-z</code> raises the mesh 5 cm so the grounded-zmin hygiene budget fails and exit 16 fires.</p>
 <h2>Run</h2>
 <pre><code>blender --background --python hitching_post.py --
 blender --background --python hitching_post.py -- --skip-decimate
+blender --background --python hitching_post.py -- --lift-z
 blender --background --python hitching_post.py -- --output hitching-post.png</code></pre>
-<p>Smoke does not pass <code>--output</code> or <code>--skip-decimate</code>.</p>
+<p>Smoke does not pass <code>--output</code>, <code>--skip-decimate</code>, or <code>--lift-z</code>.</p>
 <h2>Exit codes</h2>
 <p>File-local. <code>9</code> is a valid check code. <code>10</code> is reserved for <code>gallery_framing.check_framing</code> on the <code>--output</code> path.</p>
-<p>| Code | Meaning | | --- | --- | | 0 | Success | | 1 | Uncaught exception (FATAL wrapper) | | 2 | argparse / usage | | 3 | Mesh did not build / no UV layer | | 4 | Base triangle count outside range | | 5 | Material count ≠ 2 distinct slots, or wood/metal faces missing | | 6 | UVs outside 0..1 | | 7 | UV AABB overlap above tolerance | | 8 | World AABB off declared outer size | | 9 | LOD ratio band (<code>--skip-decimate</code> lands here) | | 10 | Framing gate (render path only) | | 11 | Collider triangle count above ceiling | | 12 | Bake did not finish or image has no data | | 13 | Export file missing or empty | | 14 | <code>--output</code> produced no file |</p>
+<p>| Code | Meaning | | --- | --- | | 0 | Success | | 1 | Uncaught exception (FATAL wrapper) | | 2 | argparse / usage | | 3 | Mesh did not build / no UV layer | | 4 | Base triangle count outside range | | 5 | Material count ≠ 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: loose verts/edges, non-manifold, zero-area, doubles, or n-gons | | 16 | Grounded zmin (<code>--lift-z</code> lands here) | | 17 | Wood–metal BVH gap above 8 mm |</p>
     </section>
     <section class="detail-section src">
       <h2>Source</h2>
@@ -292,7 +294,8 @@ <h2>Source</h2>
 
 Budgets are declared below and recomputed from the generated result.
 They are not API-contract witnesses. ``--skip-decimate`` skips the LOD
-DECIMATE stage so the LOD-ratio budget fails.
+DECIMATE stage so the LOD-ratio budget fails. ``--lift-z`` raises the
+mesh so the grounded-zmin hygiene budget fails.
 
 No RNG. Construction is closed-form. DECIMATE COLLAPSE triangle counts
 are not byte-identical across Blender versions — the LOD gate is a
@@ -300,6 +303,7 @@ <h2>Source</h2>
 
     blender --background --python hitching_post.py --
     blender --background --python hitching_post.py -- --skip-decimate
+    blender --background --python hitching_post.py -- --lift-z
     blender --background --python hitching_post.py -- --output hitching-post.png
 &quot;&quot;&quot;</span>
 <span class="k">import</span> argparse
@@ -312,6 +316,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)
@@ -323,22 +328,27 @@ <h2>Source</h2>
 POST_W = <span class="n">0.125</span>
 POST_H = <span class="n">1.16</span>
 CAP_H = <span class="n">0.10</span>
-SHOE_H = <span class="n">0.050</span>
-SHOE_SCALE = <span class="n">1.34</span>
+CAP_EMBED = <span class="n">0.002</span>
+SHOE_H = <span class="n">0.055</span>
+SHOE_T = <span class="n">0.014</span>
+SHOE_SCALE = <span class="n">1.38</span>
 ARM_Z = <span class="n">0.90</span>
 ARM_L = <span class="n">0.46</span>
 ARM_Y = <span class="n">0.056</span>
 ARM_ZTH = <span class="n">0.056</span>
-RING_MAJOR = <span class="n">0.058</span>
-RING_MINOR = <span class="n">0.011</span>
-BAND_H = <span class="n">0.030</span>
-BAND_T = <span class="n">0.012</span>
+TENON_SCALE = <span class="n">0.62</span>
+RING_MAJOR = <span class="n">0.052</span>
+RING_MINOR = <span class="n">0.009</span>
+EYE_MAJOR = <span class="n">0.015</span>
+EYE_MINOR = <span class="n">0.005</span>
+BAND_H = <span class="n">0.028</span>
+BAND_T = <span class="n">0.010</span>
 BAND_ZS = (<span class="n">0.20</span>, <span class="n">0.52</span>)
 
 BBOX_TOL = <span class="n">0.01</span>
-OUTER_SIZE = (<span class="n">0.460</span>, <span class="n">0.194</span>, <span class="n">1.260</span>)
-BASE_TRIS_MIN = <span class="n">780</span>
-BASE_TRIS_MAX = <span class="n">920</span>
+OUTER_SIZE = (<span class="n">0.460</span>, <span class="n">0.191</span>, <span class="n">1.258</span>)
+BASE_TRIS_MIN = <span class="n">900</span>
+BASE_TRIS_MAX = <span class="n">1800</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,11 +358,16 @@ <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">180</span>
+COLLIDER_TRIS_MAX = <span class="n">280</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>
+ZMIN_EPS = <span class="n">1e-4</span>
+DOUBLES_EPS = <span class="n">1e-5</span>
+AREA_EPS = <span class="n">1e-10</span>
+GAP_MAX = <span class="n">0.008</span>
+LIFT_Z = <span class="n">0.05</span>
 
 WOOD_IDX = <span class="n">0</span>
 METAL_IDX = <span class="n">1</span>
@@ -464,19 +479,18 @@ <h2>Source</h2>
     <span class="k">return</span> verts
 
 
-<span class="k">def</span> add_rim(bm, loc, major, minor, mat_idx, euler=(<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>)):
-    n_major = <span class="n">14</span>
-    n_minor = <span class="n">7</span>
+<span class="k">def</span> add_rim(bm, loc, major, minor, mat_idx, euler=(<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>), n_major=<span class="n">18</span>, n_minor=<span class="n">8</span>):
     rings = []
     <span class="k">for</span> i <span class="k">in</span> range(n_major):
         u = i * (<span class="n">2.0</span> * math.pi / n_major)
         ring = []
         <span class="k">for</span> j <span class="k">in</span> range(n_minor):
             v = j * (<span class="n">2.0</span> * math.pi / n_minor)
-            x = (major + minor * math.cos(v)) * math.cos(u)
-            y = (major + minor * math.cos(v)) * math.sin(u)
-            z = minor * math.sin(v)
-            ring.append(bm.verts.new((x, y, z)))
+            ring.append(bm.verts.new((
+                (major + minor * math.cos(v)) * math.cos(u),
+                (major + minor * math.cos(v)) * math.sin(u),
+                minor * math.sin(v),
+            )))
         rings.append(ring)
     bm.verts.ensure_lookup_table()
     <span class="k">for</span> i <span class="k">in</span> range(n_major):
@@ -496,12 +510,120 @@ <h2>Source</h2>
 
 
 <span class="k">def</span> add_square_band(bm, z, half, t, h, mat_idx):
-    metal = []
-    metal.extend(add_box(bm, (<span class="n">0.0</span>, half + t / <span class="n">2.0</span>, z), (<span class="n">2.0</span> * half + <span class="n">2.0</span> * t, t, h), mat_idx))
-    metal.extend(add_box(bm, (<span class="n">0.0</span>, -(half + t / <span class="n">2.0</span>), z), (<span class="n">2.0</span> * half + <span class="n">2.0</span> * t, t, h), mat_idx))
-    metal.extend(add_box(bm, (half + t / <span class="n">2.0</span>, <span class="n">0.0</span>, z), (t, <span class="n">2.0</span> * half, h), mat_idx))
-    metal.extend(add_box(bm, (-(half + t / <span class="n">2.0</span>), <span class="n">0.0</span>, z), (t, <span class="n">2.0</span> * half, h), mat_idx))
-    <span class="k">return</span> metal
+    <span class="s">&quot;&quot;&quot;Closed square collar in XY, extruded along Z. One manifold torus.&quot;&quot;&quot;</span>
+    z0 = z - h * <span class="n">0.5</span>
+    z1 = z + h * <span class="n">0.5</span>
+    inner = (
+        (half, half),
+        (-half, half),
+        (-half, -half),
+        (half, -half),
+    )
+    outer = (
+        (half + t, half + t),
+        (-(half + t), half + t),
+        (-(half + t), -(half + t)),
+        (half + t, -(half + t)),
+    )
+
+    <span class="k">def</span> ring(zc, pts):
+        <span class="k">return</span> [bm.verts.new((p[<span class="n">0</span>], p[<span class="n">1</span>], zc)) <span class="k">for</span> p <span class="k">in</span> pts]
+
+    i0 = ring(z0, inner)
+    o0 = ring(z0, outer)
+    i1 = ring(z1, inner)
+    o1 = ring(z1, outer)
+
+    <span class="k">def</span> quad(a, b, c, d):
+        face = bm.faces.new((a, b, c, d))
+        face.material_index = mat_idx
+        <span class="k">return</span> face
+
+    <span class="k">for</span> k <span class="k">in</span> range(<span class="n">4</span>):
+        n = (k + <span class="n">1</span>) % <span class="n">4</span>
+        quad(i0[k], i0[n], i1[n], i1[k])
+        quad(o0[k], o1[k], o1[n], o0[n])
+        quad(i0[k], o0[k], o0[n], i0[n])
+        quad(i1[k], i1[n], o1[n], o1[k])
+    <span class="k">return</span> i0 + o0 + i1 + o1
+
+
+<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):
+    <span class="c"># Combinatorics match examples/mesh-hygiene-audit.audit (copied, not imported).</span>
+    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>)
+    areas = [face_area(me, p) <span class="k">for</span> p <span class="k">in</span> me.polygons]
+    zero_area = sum(<span class="n">1</span> <span class="k">for</span> a <span class="k">in</span> areas <span class="k">if</span> a &lt;= AREA_EPS)
+    bm = bmesh.new()
+    <span class="k">try</span>:
+        bm.from_mesh(me)
+        bm.verts.ensure_lookup_table()
+        bm.edges.ensure_lookup_table()
+        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> min_mat_distance(me, ia, ib):
+    <span class="s">&quot;&quot;&quot;Closest surface distance between two material islands via BVH.&quot;&quot;&quot;</span>
+    bm_a = bmesh.new()
+    bm_b = bmesh.new()
+    <span class="k">try</span>:
+        bm_a.from_mesh(me)
+        bm_b.from_mesh(me)
+        bm_a.faces.ensure_lookup_table()
+        bm_b.faces.ensure_lookup_table()
+        drop_a = [f <span class="k">for</span> f <span class="k">in</span> bm_a.faces <span class="k">if</span> f.material_index != ia]
+        drop_b = [f <span class="k">for</span> f <span class="k">in</span> bm_b.faces <span class="k">if</span> f.material_index != ib]
+        <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">None</span>:
+                <span class="k">continue</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">None</span>:
+                <span class="k">continue</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> pack_uvs(bm, margin=<span class="n">0.08</span>):
@@ -551,8 +673,8 @@ <h2>Source</h2>
     bm = bmesh.new()
     <span class="k">try</span>:
         wood = []
-        metal = []
         half = POST_W / <span class="n">2.0</span>
+        cap_r = half * math.sqrt(<span class="n">2.0</span>)
 
         wood.extend(
             add_box(
@@ -562,29 +684,50 @@ <h2>Source</h2>
                 WOOD_IDX,
             )
         )
+        <span class="c"># Pyramid whose base vertices land on the post corners, then embed</span>
+        <span class="c"># 2mm so the cap/post plane cannot z-fight.</span>
         wood.extend(
             add_cone(
                 bm,
-                (<span class="n">0.0</span>, <span class="n">0.0</span>, POST_H + CAP_H / <span class="n">2.0</span>),
-                POST_W * <span class="n">0.78</span>,
-                <span class="n">0.012</span>,
+                (<span class="n">0.0</span>, <span class="n">0.0</span>, POST_H + CAP_H / <span class="n">2.0</span> - CAP_EMBED),
+                cap_r,
+                <span class="n">0.008</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>),
             )
         )
+        stub = ARM_L / <span class="n">2.0</span> - half
+        tenon_y = ARM_Y * TENON_SCALE
+        tenon_z = ARM_ZTH * TENON_SCALE
         wood.extend(
             add_box(
                 bm,
                 (<span class="n">0.0</span>, <span class="n">0.0</span>, ARM_Z),
-                (ARM_L, ARM_Y, ARM_ZTH),
+                (POST_W + <span class="n">0.012</span>, tenon_y, tenon_z),
+                WOOD_IDX,
+            )
+        )
+        wood.extend(
+            add_box(
+                bm,
+                (half + stub / <span class="n">2.0</span>, <span class="n">0.0</span>, ARM_Z),
+                (stub, ARM_Y, ARM_ZTH),
+                WOOD_IDX,
+            )
+        )
+        wood.extend(
+            add_box(
+                bm,
+                (-(half + stub / <span class="n">2.0</span>), <span class="n">0.0</span>, ARM_Z),
+                (stub, ARM_Y, ARM_ZTH),
                 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 <span class="k">for</span> e <span class="k">in</span> v.link_edges})
+            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 <span class="k">if</span> v.is_valid})
             ret = bmesh.ops.bevel(
                 bm,
                 geom=edges,
@@ -597,38 +740,46 @@ <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
 
-        metal.extend(
-            add_box(
-                bm,
-                (<span class="n">0.0</span>, <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,
-            )
-        )
+        <span class="c"># Shoe is a collar whose inner faces sit on the post, not a solid plate</span>
+        <span class="c"># the post punches through.</span>
+        add_square_band(bm, SHOE_H / <span class="n">2.0</span>, half - <span class="n">0.002</span>, SHOE_T, SHOE_H, METAL_IDX)
         <span class="k">for</span> z <span class="k">in</span> BAND_ZS:
-            metal.extend(add_square_band(bm, z, half, BAND_T, BAND_H, METAL_IDX))
+            add_square_band(bm, z, half - <span class="n">0.002</span>, BAND_T, BAND_H, METAL_IDX)
 
-        ring_y = -(max(POST_W, ARM_Y) / <span class="n">2.0</span> + RING_MINOR + <span class="n">0.006</span>)
+        arm_y_face = -(ARM_Y / <span class="n">2.0</span>)
         <span class="k">for</span> sx <span class="k">in</span> (-ARM_L * <span class="n">0.32</span>, ARM_L * <span class="n">0.32</span>):
-            metal.extend(
-                add_box(
-                    bm,
-                    (sx, ring_y + RING_MINOR + <span class="n">0.010</span>, ARM_Z),
-                    (<span class="n">0.018</span>, <span class="n">0.022</span>, <span class="n">0.018</span>),
-                    METAL_IDX,
-                )
+            <span class="c"># Eye on the -Y arm face; hitching ring threads it (YZ vs XZ).</span>
+            add_rim(
+                bm,
+                (sx, arm_y_face + EYE_MINOR * <span class="n">0.25</span>, ARM_Z),
+                EYE_MAJOR,
+                EYE_MINOR,
+                METAL_IDX,
+                euler=(math.pi / <span class="n">2.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>),
+                n_major=<span class="n">14</span>,
+                n_minor=<span class="n">7</span>,
             )
-            metal.extend(
-                add_rim(
-                    bm,
-                    (sx, ring_y - RING_MAJOR * <span class="n">0.35</span>, ARM_Z - RING_MAJOR * <span class="n">0.15</span>),
-                    RING_MAJOR,
-                    RING_MINOR,
-                    METAL_IDX,
-                    euler=(math.pi / <span class="n">2.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>),
-                )
+            add_rim(
+                bm,
+                (
+                    sx,
+                    arm_y_face - RING_MAJOR * <span class="n">0.55</span>,
+                    ARM_Z - RING_MAJOR * <span class="n">0.28</span>,
+                ),
+                RING_MAJOR,
+                RING_MINOR,
+                METAL_IDX,
+                euler=(<span class="n">0.0</span>, math.pi / <span class="n">2.0</span>, <span class="n">0.0</span>),
+                n_major=<span class="n">18</span>,
+                n_minor=<span class="n">8</span>,
             )
 
+        bmesh.ops.remove_doubles(bm, verts=list(bm.verts), dist=DOUBLES_EPS)
+        bm.faces.ensure_lookup_table()
+        degen = [f <span class="k">for</span> f <span class="k">in</span> bm.faces <span class="k">if</span> f.calc_area() &lt;= AREA_EPS]
+        <span class="k">if</span> degen:
+            bmesh.ops.delete(bm, geom=degen, context=<span class="s">&quot;FACES&quot;</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]
@@ -645,12 +796,20 @@ <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>
+            <span class="k">if</span> face.material_index == METAL_IDX:
+                face.smooth = <span class="k">True</span>
+            <span class="k">else</span>:
+                face.smooth = <span class="k">False</span>
+        <span class="k">for</span> edge <span class="k">in</span> bm.edges:
+            <span class="k">if</span> <span class="k">not</span> edge.is_manifold <span class="k">or</span> len(edge.link_faces) != <span class="n">2</span>:
+                <span class="k">continue</span>
+            <span class="k">if</span> edge.calc_face_angle() &gt; math.radians(<span class="n">35.0</span>):
+                edge.smooth = <span class="k">False</span>
         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)
@@ -658,13 +817,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
 
 
@@ -797,14 +968,25 @@ <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>):
     bpy.ops.wm.read_factory_settings(use_empty=<span class="k">True</span>)
-    low = build_hitching_post_mesh(<span class="s">&quot;HitchPostLow&quot;</span>, bevel_offset=<span class="n">0.004</span>, bevel_segments=<span class="n">2</span>)
-    high = build_hitching_post_mesh(<span class="s">&quot;HitchPostHigh&quot;</span>, bevel_offset=<span class="n">0.004</span>, bevel_segments=<span class="n">4</span>)
-    wood = principled(<span class="s">&quot;HitchPostWood&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;HitchPostIron&quot;</span>, (<span class="n">0.14</span>, <span class="n">0.145</span>, <span class="n">0.155</span>, <span class="n">1.0</span>), <span class="n">1.0</span>, <span class="n">0.38</span>)
+    low = build_hitching_post_mesh(<span class="s">&quot;HitchPostLow&quot;</span>, bevel_offset=<span class="n">0.008</span>, bevel_segments=<span class="n">2</span>)
+    high = build_hitching_post_mesh(<span class="s">&quot;HitchPostHigh&quot;</span>, bevel_offset=<span class="n">0.008</span>, bevel_segments=<span class="n">4</span>)
+    wood = principled(
+        <span class="s">&quot;HitchPostWood&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.62</span>,
+        noise_scale=<span class="n">11.0</span>,
+        wear=(<span class="n">0.24</span>, <span class="n">0.13</span>, <span class="n">0.05</span>, <span class="n">1.0</span>),
+    )
+    metal = principled(<span class="s">&quot;HitchPostIron&quot;</span>, (<span class="n">0.12</span>, <span class="n">0.125</span>, <span class="n">0.135</span>, <span class="n">1.0</span>), <span class="n">1.0</span>, <span class="n">0.42</span>)
     assign_slots(low, wood, metal)
     assign_slots(high, wood, metal)
+    <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;hitching post 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>
@@ -865,10 +1047,18 @@ <h2>Source</h2>
         <span class="s">f&quot;</span><span class="s">measured bbox=(</span>{size_x:<span class="s">.4f</span>}<span class="s">,</span>{size_y:<span class="s">.4f</span>}<span class="s">,</span>{size_z:<span class="s">.4f</span>}<span class="s">) </span><span class="s">&quot;</span>
         <span class="s">f&quot;</span><span class="s">outer=</span>{OUTER_SIZE}<span class="s"> zmin=</span>{bb[<span class="n">2</span>]:<span class="s">.4f</span>}<span class="s">&quot;</span>
     )
+    hyg = hygiene_audit(low.data)
+    gap = min_mat_distance(low.data, METAL_IDX, WOOD_IDX)
     print(
         <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"> euler=</span>{hyg[<span class="s">&#x27;euler&#x27;</span>]}<span class="s">&quot;</span>
+    )
+    print(<span class="s">f&quot;</span><span class="s">measured wood_metal_gap=</span>{gap:<span class="s">.5f</span>}<span class="s"> zmin=</span>{bb[<span class="n">2</span>]:<span class="s">.6f</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(
@@ -933,6 +1123,31 @@ <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">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">&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">if</span> abs(bb[<span class="n">2</span>]) &gt; ZMIN_EPS:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">zmin </span>{bb[<span class="n">2</span>]:<span class="s">.6f</span>}<span class="s"> not within </span>{ZMIN_EPS}<span class="s"> of 0 </span><span class="s">&quot;</span>
+            <span class="s">&quot;(--lift-z is the designed fail)&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> gap &gt; GAP_MAX:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">wood-metal gap </span>{gap:<span class="s">.5f</span>}<span class="s"> &gt; </span>{GAP_MAX}<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">return</span> <span class="n">0</span>, low, high, wood, tex, collider
 
 
@@ -1051,9 +1266,14 @@ <h2>Source</h2>
         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;--lift-z&quot;</span>,
+        action=<span class="s">&quot;store_true&quot;</span>,
+        help=<span class="s">&quot;falsification: lift the mesh so zmin fails the grounded budget&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)
     <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 2642789..8915f9c 100644
--- a/docs/gallery/index.html
+++ b/docs/gallery/index.html
@@ -1052,12 +1052,12 @@ <h2><a href="water-trough/">water-trough</a></h2>
       </article>
       <article class="card" data-tags="mesh export showcase">
         <a class="card-media" href="hitching-post/" aria-label="hitching-post example detail page">
-          <img src="assets/hitching-post-hero.webp" alt="hitching-post — A procedural hitching post through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." loading="lazy" decoding="async" />
+          <img src="assets/hitching-post-hero.webp" alt="hitching-post — A procedural hitching post (corner-aligned cap, stub-and-tenon arm, collar shoe, eye-threaded rings) through UVs, bake, LOD, collider, and Unity glTF…" loading="lazy" decoding="async" />
         </a>
         <div class="card-body">
           <h2><a href="hitching-post/">hitching-post</a></h2>
-          <p class="teaches">A procedural hitching post 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: 848 tris, two materials with 262 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.460×0.194×1.260 m, LOD ratios in band (5.2 COLLAPSE more aggressive on LOD2), convex collider 144 tris, non-empty glTF. --skip-decimate exits 9 on the LOD1 ratio budget.</p>
+          <p class="teaches">A procedural hitching post (corner-aligned cap, stub-and-tenon arm, collar shoe, eye-threaded rings) 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: 1598 tris, two materials with 269 wood and 532 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.460×0.191×1.258 m, zmin 0, hygiene 0, wood-metal BVH gap 0.45 mm, LOD ratios in band, convex collider 78 tris, non-empty glTF. --skip-decimate exits 9 on LOD1; --lift-z exits 16 on grounded zmin.</p>
           <a class="card-link" href="hitching-post/">View example <span aria-hidden="true">&rarr;</span></a>
         </div>
       </article>
@@ -1162,12 +1162,12 @@ <h2><a href="wooden-ladder/">wooden-ladder</a></h2>
       </article>
       <article class="card" data-tags="mesh export showcase">
         <a class="card-media" href="hay-bale/" aria-label="hay-bale example detail page">
-          <img src="assets/hay-bale-hero.webp" alt="hay-bale — A procedural bound hay bale with a bevelled loaf, end nap, and two sisal twine belts through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed…" loading="lazy" decoding="async" />
+          <img src="assets/hay-bale-hero.webp" alt="hay-bale — A procedural bound hay bale with a cinched pillow loaf, end nap, and two sisal twine belts through UVs, bake, LOD, collider, and Unity glTF, asserting…" loading="lazy" decoding="async" />
         </a>
         <div class="card-body">
           <h2><a href="hay-bale/">hay-bale</a></h2>
-          <p class="teaches">A procedural bound hay bale with a bevelled loaf, end nap, and two sisal twine belts 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: 252 tris, two materials with 66 hay and 60 twine faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.916×0.520×0.401 m, LOD ratios in band (5.2 COLLAPSE more aggressive), convex collider 68 tris, non-empty glTF. --skip-decimate exits 9 on the LOD1 ratio budget.</p>
+          <p class="teaches">A procedural bound hay bale with a cinched pillow loaf, end nap, and two sisal twine belts 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: 852 tris, two materials with 294 hay and 132 twine faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.920×0.517×0.426 m, zmin 0, hygiene 0, hay-twine BVH gap 0.07 mm, LOD ratios in band, convex collider 78 tris, non-empty glTF. --skip-decimate exits 9 on LOD1; --lift-z exits 16 on grounded zmin.</p>
           <a class="card-link" href="hay-bale/">View example <span aria-hidden="true">&rarr;</span></a>
         </div>
       </article>
diff --git a/showcase/README.md b/showcase/README.md
index 31c3c96..5896fe7 100644
--- a/showcase/README.md
+++ b/showcase/README.md
@@ -33,7 +33,16 @@ entry in `showcase/gallery.json`, and a rendered still.
   assigned `DECLARED` is not a check).
 - **Falsifier** breaks one pipeline stage so a **named** budget fails and
   the piece exits its documented code. Prove default and falsifier on
-  4.5.11, 5.1.2, and 5.2.1.
+  4.5.11, 5.1.2, and 5.2.1. `--skip-decimate` is the LOD-ratio
+  falsifier (exit 9). `--lift-z` is the grounded-zmin falsifier (exit 16).
+- **Hygiene budgets.** Copied combinatorics from
+  `examples/mesh-hygiene-audit` (do not import the example). Every piece
+  asserts on the generated mesh: non-manifold edges 0, loose verts 0,
+  loose edges 0, doubles at 1e-5 0, zero-area faces 0, n-gons 0, world
+  AABB min Z within 1e-4 of 0. Multi-body props do **not** require Euler
+  characteristic 2 — that is a single-shell contract. Pairs of parts
+  meant to touch assert a BVH surface gap below a named epsilon
+  (vert-vert is the wrong metric for thin straps and collars).
 - **Exit codes** are file-local: `0` success, argparse `2`, `3` and above
   in check order. `9` is legal. FATAL `sys.exit(1)` is a crash, never a
   named check.
diff --git a/showcase/gallery.json b/showcase/gallery.json
index 96e4d22..09b5d48 100644
--- a/showcase/gallery.json
+++ b/showcase/gallery.json
@@ -188,8 +188,8 @@
     {
       "name": "hitching-post",
       "dir": "showcase/hitching-post",
-      "teaches": "A procedural hitching post through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.",
-      "witnessesFix": "Recomputed: 848 tris, two materials with 262 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.460×0.194×1.260 m, LOD ratios in band (5.2 COLLAPSE more aggressive on LOD2), convex collider 144 tris, non-empty glTF. --skip-decimate exits 9 on the LOD1 ratio budget.",
+      "teaches": "A procedural hitching post (corner-aligned cap, stub-and-tenon arm, collar shoe, eye-threaded rings) through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.",
+      "witnessesFix": "Recomputed: 1598 tris, two materials with 269 wood and 532 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.460×0.191×1.258 m, zmin 0, hygiene 0, wood-metal BVH gap 0.45 mm, LOD ratios in band, convex collider 78 tris, non-empty glTF. --skip-decimate exits 9 on LOD1; --lift-z exits 16 on grounded zmin.",
       "hero": "docs/gallery/assets/hitching-post-hero.webp",
       "preview": "showcase/hitching-post/preview.webp",
       "tags": [
@@ -308,8 +308,8 @@
     {
       "name": "hay-bale",
       "dir": "showcase/hay-bale",
-      "teaches": "A procedural bound hay bale with a bevelled loaf, end nap, and two sisal twine belts through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.",
-      "witnessesFix": "Recomputed: 252 tris, two materials with 66 hay and 60 twine faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.916×0.520×0.401 m, LOD ratios in band (5.2 COLLAPSE more aggressive), convex collider 68 tris, non-empty glTF. --skip-decimate exits 9 on the LOD1 ratio budget.",
+      "teaches": "A procedural bound hay bale with a cinched pillow loaf, end nap, and two sisal twine belts through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.",
+      "witnessesFix": "Recomputed: 852 tris, two materials with 294 hay and 132 twine faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.920×0.517×0.426 m, zmin 0, hygiene 0, hay-twine BVH gap 0.07 mm, LOD ratios in band, convex collider 78 tris, non-empty glTF. --skip-decimate exits 9 on LOD1; --lift-z exits 16 on grounded zmin.",
       "hero": "docs/gallery/assets/hay-bale-hero.webp",
       "preview": "showcase/hay-bale/preview.webp",
       "tags": [
diff --git a/showcase/hay-bale/README.md b/showcase/hay-bale/README.md
index a4d534c..36ec1a8 100644
--- a/showcase/hay-bale/README.md
+++ b/showcase/hay-bale/README.md
@@ -1,9 +1,9 @@
 # Hay bale
 
-A showcase piece, not an example. Procedural bound straw bale (bevelled
-loaf, end nap, two sisal twine belts) then the shipped pipeline:
-unique-cell UVs, Cycles high-to-low normal bake, LOD chain, convex
-collider, Unity glTF export.
+A showcase piece, not an example. Procedural bound straw bale (cinched
+pillow loaf, end nap, two square-torus sisal belts with hitch loops)
+then the shipped pipeline: unique-cell UVs, Cycles high-to-low normal
+bake, LOD chain, convex collider, Unity glTF export.
 
 It asserts **budget conformance** of the generated result. It does not
 witness an API contract. "It rendered without error" is not a check.
@@ -13,6 +13,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: 0.90 × 0.48 × 0.38 m core loaf; outer AABB includes
+cinch bulge and belts.
 
 ## Budgets
 
@@ -21,34 +26,38 @@ materials, UVs, evaluated LOD, collider, or export file.
 
 | Axis | Declared | Measured (4.5.11 / 5.1.2 / 5.2.1) |
 | --- | --- | --- |
-| Base triangles | 220–290 | 252 / 252 / 252 |
-| LOD1 ratio | 0.32–0.62 of base | 0.5000 / 0.5000 / 0.4683 |
-| LOD2 ratio | 0.10–0.35 of base | 0.2143 / 0.2143 / 0.1429 |
-| Materials | exactly 2 distinct, ≥24 hay, ≥24 twine | 2 slots, 66 hay, 60 twine |
+| Base triangles | 750–1100 | 852 / 852 / 852 |
+| LOD1 ratio | 0.32–0.62 of base | 0.5000 / 0.5000 / 0.5000 |
+| LOD2 ratio | 0.10–0.35 of base | 0.2183 / 0.2183 / 0.2183 |
+| Materials | exactly 2 distinct, ≥24 hay, ≥24 twine | 2 slots, 294 hay, 132 twine |
 | UVs | in `0..1`, AABB overlap ≤ 1e-5 | in range, overlap 0 |
-| Outer AABB | (0.916, 0.520, 0.401) m ± 0.01 | (0.9160, 0.5200, 0.4010), zmin 0 |
-| Collider tris | ≤ 120 | 68 |
-| Export | written, size > 0 | 25944 / 25944 / 25936 bytes |
+| Outer AABB | (0.920, 0.517, 0.426) m ± 0.01 | (0.9199, 0.5170, 0.4257) |
+| Grounded zmin | within 1e-4 of 0 | 0 / 0 / 0 |
+| Hygiene | loose/nonman/zero-area/doubles/ngons = 0 | 0 / 0 / 0 |
+| Hay–twine gap | BVH surface < 0.008 m | 0.00007 / 0.00007 / 0.00007 |
+| Collider tris | ≤ 400 | 78 |
+| Export | written, size > 0 | 70720 / 70720 / 70712 bytes |
 
 DECIMATE COLLAPSE triangle counts are **not** identical across series —
-5.2.1 is more aggressive on both LOD ratios. 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.
+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.
+exit 9 fires. `--lift-z` raises the mesh 5 cm so the grounded-zmin
+hygiene budget fails and exit 16 fires.
 
 ## Run
 
 ```bash
 blender --background --python hay_bale.py --
 blender --background --python hay_bale.py -- --skip-decimate
+blender --background --python hay_bale.py -- --lift-z
 blender --background --python hay_bale.py -- --output bale.png
 ```
 
-Smoke does not pass `--output` or `--skip-decimate`.
+Smoke does not pass `--output`, `--skip-decimate`, or `--lift-z`.
 
 ## Exit codes
 
@@ -72,3 +81,6 @@ 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: loose verts/edges, non-manifold, zero-area, doubles, or n-gons |
+| 16 | Grounded zmin (`--lift-z` lands here) |
+| 17 | Hay–twine BVH gap above 8 mm |
diff --git a/showcase/hay-bale/hay_bale.py b/showcase/hay-bale/hay_bale.py
index c72af21..04fec2b 100644
--- a/showcase/hay-bale/hay_bale.py
+++ b/showcase/hay-bale/hay_bale.py
@@ -6,7 +6,8 @@
 
 Budgets are declared below and recomputed from the generated result.
 They are not API-contract witnesses. ``--skip-decimate`` skips the LOD
-DECIMATE stage so the LOD-ratio budget fails.
+DECIMATE stage so the LOD-ratio budget fails. ``--lift-z`` raises the
+mesh so the grounded-zmin hygiene budget fails.
 
 No RNG. Construction is closed-form. DECIMATE COLLAPSE triangle counts
 are not byte-identical across Blender versions — the LOD gate is a
@@ -14,6 +15,7 @@
 
     blender --background --python hay_bale.py --
     blender --background --python hay_bale.py -- --skip-decimate
+    blender --background --python hay_bale.py -- --lift-z
     blender --background --python hay_bale.py -- --output bale.png
 """
 import argparse
@@ -26,6 +28,7 @@
 import bmesh
 import bpy
 from mathutils import Euler, Vector
+from mathutils.bvhtree import BVHTree
 
 # Showcase lives at repo-root/showcase/, not under examples/. The framing
 # helper is the repo's only shared import and lives next to the examples;
@@ -40,15 +43,24 @@
 BALE_X = 0.90
 BALE_Y = 0.48
 BALE_Z = 0.38
-TWINE_T = 0.014
-TWINE_W = 0.026
-TWINE_PAD = 0.006
+TWINE_T = 0.012
+TWINE_W = 0.028
+TWINE_EMBED = 0.003
+BELT_XS = (-0.225, 0.225)
+LOAF_CUTS = 4
+BULGE = 0.055
+RIDGE_AMP = 0.007
 BBOX_TOL = 0.01
 # Fitted after locking geometry. Recomputed from bound_box.
-OUTER_SIZE = (0.916, 0.520, 0.401)
-
-BASE_TRIS_MIN = 220
-BASE_TRIS_MAX = 290
+OUTER_SIZE = (0.920, 0.517, 0.426)
+
+BASE_TRIS_MIN = 750
+BASE_TRIS_MAX = 1100
+ZMIN_EPS = 1e-4
+DOUBLES_EPS = 1e-5
+AREA_EPS = 1e-10
+GAP_MAX = 0.008
+LIFT_Z = 0.05
 LOD1_RATIO_MIN = 0.32
 LOD1_RATIO_MAX = 0.62
 LOD2_RATIO_MIN = 0.10
@@ -58,7 +70,7 @@
 MATERIAL_COUNT = 2
 UV_EPS = 1e-4
 UV_OVERLAP_MAX = 1e-5
-COLLIDER_TRIS_MAX = 120
+COLLIDER_TRIS_MAX = 400
 BAKE_RES = 256
 CAGE_EXTRUSION = 0.04
 HAY_FACES_MIN = 24
@@ -108,6 +120,150 @@ def add_box(bm, loc, scale, mat_idx, euler=(0.0, 0.0, 0.0)):
     return verts
 
 
+def add_rim(bm, loc, major, minor, mat_idx, euler=(0.0, 0.0, 0.0), n_major=12, n_minor=6):
+    rings = []
+    for i in range(n_major):
+        u = i * (2.0 * math.pi / n_major)
+        ring = []
+        for j in range(n_minor):
+            v = j * (2.0 * math.pi / n_minor)
+            ring.append(bm.verts.new((
+                (major + minor * math.cos(v)) * math.cos(u),
+                (major + minor * math.cos(v)) * math.sin(u),
+                minor * math.sin(v),
+            )))
+        rings.append(ring)
+    bm.verts.ensure_lookup_table()
+    for i in range(n_major):
+        i2 = (i + 1) % n_major
+        for j in range(n_minor):
+            j2 = (j + 1) % n_minor
+            face = bm.faces.new((rings[i][j], rings[i2][j], rings[i2][j2], rings[i][j2]))
+            face.material_index = mat_idx
+    verts = [v for ring in rings for v in ring]
+    rot = Euler(euler).to_matrix()
+    origin = Vector(loc)
+    for v in verts:
+        v.co = rot @ v.co + origin
+    return verts
+
+
+def add_square_wrap(bm, x, y_half, z_lo, z_hi, t, w, mat_idx):
+    """Closed rectangular belt in YZ, extruded along X. One manifold torus."""
+    x0 = x - w * 0.5
+    x1 = x + w * 0.5
+    inner = (
+        (y_half, z_lo),
+        (y_half, z_hi),
+        (-y_half, z_hi),
+        (-y_half, z_lo),
+    )
+    outer = (
+        (y_half + t, z_lo - t),
+        (y_half + t, z_hi + t),
+        (-y_half - t, z_hi + t),
+        (-y_half - t, z_lo - t),
+    )
+
+    def ring(xc, pts):
+        return [bm.verts.new((xc, p[0], p[1])) for p in pts]
+
+    i0 = ring(x0, inner)
+    o0 = ring(x0, outer)
+    i1 = ring(x1, inner)
+    o1 = ring(x1, outer)
+
+    def quad(a, b, c, d):
+        face = bm.faces.new((a, b, c, d))
+        face.material_index = mat_idx
+        return face
+
+    for k in range(4):
+        n = (k + 1) % 4
+        quad(i0[k], i1[k], i1[n], i0[n])
+        quad(o0[k], o0[n], o1[n], o1[k])
+        quad(i0[k], i0[n], o0[n], o0[k])
+        quad(i1[k], o1[k], o1[n], i1[n])
+
+
+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):
+    # Combinatorics match examples/mesh-hygiene-audit.audit (copied, not imported).
+    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)
+    areas = [face_area(me, p) for p in me.polygons]
+    zero_area = sum(1 for a in areas if a <= AREA_EPS)
+    bm = bmesh.new()
+    try:
+        bm.from_mesh(me)
+        bm.verts.ensure_lookup_table()
+        bm.edges.ensure_lookup_table()
+        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 min_mat_distance(me, ia, ib):
+    """Closest surface distance between two material islands via BVH.
+
+    Vert-vert distance is the wrong metric for a 4-corner strap: the inner
+    face has no mid-edge verts, so a cinched belt still reports ~TWINE_W/2.
+    """
+    bm_a = bmesh.new()
+    bm_b = bmesh.new()
+    try:
+        bm_a.from_mesh(me)
+        bm_b.from_mesh(me)
+        bm_a.faces.ensure_lookup_table()
+        bm_b.faces.ensure_lookup_table()
+        drop_a = [f for f in bm_a.faces if f.material_index != ia]
+        drop_b = [f for f in bm_b.faces if f.material_index != ib]
+        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 src in list(bm_a.verts) + list(bm_a.faces):
+            co = src.co if hasattr(src, "co") else src.calc_center_median()
+            hit = tree.find_nearest(co)
+            if hit[0] is None:
+                continue
+            best = min(best, hit[3])
+        return best
+    finally:
+        bm_a.free()
+        bm_b.free()
+
+
 def pack_uvs(bm, margin=0.08):
     uv = bm.loops.layers.uv.new("UVMap")
     faces = list(bm.faces)
@@ -151,6 +307,29 @@ def pack_uvs(bm, margin=0.08):
             )
 
 
+def _shape_loaf(verts):
+    hx = BALE_X * 0.5
+    hy = BALE_Y * 0.5
+    hz = BALE_Z * 0.5
+    zc = BALE_Z * 0.5
+    for v in verts:
+        x, y, z = v.co.x, v.co.y, v.co.z
+        nx = max(-1.0, min(1.0, x / hx))
+        ny = max(-1.0, min(1.0, y / hy))
+        nz = max(-1.0, min(1.0, (z - zc) / hz))
+        pillow = 1.0 + BULGE * (1.0 - nx * nx)
+        v.co.y = y * pillow
+        v.co.z = zc + (z - zc) * pillow
+        # Longitudinal straw ridges on the long faces; closed-form, no RNG.
+        ridge = RIDGE_AMP * math.sin(x * 24.0) * (0.35 + 0.65 * abs(ny))
+        v.co.y += ridge
+        v.co.z += 0.55 * RIDGE_AMP * math.sin(x * 19.0 + 0.7) * (0.35 + 0.65 * abs(nz))
+        # End-grain nap: bite the ±X faces instead of gluing on extra slabs.
+        if abs(nx) > 0.82:
+            rr = math.hypot(v.co.y / (hy * pillow), (v.co.z - zc) / (hz * pillow))
+            v.co.x += math.copysign(0.010 * math.sin(rr * 14.0), x)
+
+
 def build_bale_mesh(name, bevel_offset, bevel_segments):
     bm = bmesh.new()
     hay_verts = []
@@ -164,60 +343,62 @@ def build_bale_mesh(name, bevel_offset, bevel_segments):
                 HAY_IDX,
             )
         )
+        bmesh.ops.subdivide_edges(
+            bm,
+            edges=list({e for v in hay_verts for e in v.link_edges}),
+            cuts=LOAF_CUTS,
+            use_grid_fill=True,
+        )
+        hay_verts = [v for v in bm.verts]
+        _shape_loaf(hay_verts)
         if bevel_offset > 0.0:
-            edges = list({e for v in hay_verts for e in v.link_edges if v.is_valid})
-            if edges:
-                bmesh.ops.bevel(
-                    bm,
-                    geom=edges,
-                    offset=bevel_offset,
-                    segments=bevel_segments,
-                    profile=0.5,
-                    affect="EDGES",
-                    clamp_overlap=True,
-                )
-
-        hx = BALE_X / 2.0
-        hy = BALE_Y / 2.0
-        for sign in (-1.0, 1.0):
-            add_box(
+            bm.edges.ensure_lookup_table()
+            edges = []
+            for e in bm.edges:
+                if len(e.link_faces) != 2:
+                    continue
+                if e.calc_face_angle() > math.radians(50.0):
+                    edges.append(e)
+            if not edges:
+                edges = list(bm.edges)
+            bmesh.ops.bevel(
                 bm,
-                (sign * (hx + 0.002), 0.0, BALE_Z / 2.0),
-                (0.012, BALE_Y * 0.98, BALE_Z * 0.96),
-                HAY_IDX,
+                geom=edges,
+                offset=bevel_offset,
+                segments=bevel_segments,
+                profile=0.45,
+                affect="EDGES",
+                clamp_overlap=True,
             )
 
+        hay_now = [v for v in bm.verts]
         before = set(bm.faces)
-        for x in (-0.22, 0.22):
-            wrap_y = BALE_Y + 2.0 * TWINE_PAD + TWINE_T
-            wrap_z = BALE_Z + 2.0 * TWINE_PAD
-            add_box(bm, (x, 0.0, TWINE_T / 2.0), (TWINE_W, wrap_y, TWINE_T), TWINE_IDX)
-            add_box(
+        for x in BELT_XS:
+            near = [v for v in hay_now if abs(v.co.x - x) <= 0.08]
+            if len(near) < 8:
+                near = hay_now
+            y_max = max(abs(v.co.y) for v in near)
+            z_min = min(v.co.z for v in near)
+            z_max = max(v.co.z for v in near)
+            # Sit the belt in the ridge troughs so it cinches the peaks.
+            y_half = y_max - RIDGE_AMP - TWINE_EMBED
+            z_lo = z_min + RIDGE_AMP + TWINE_EMBED
+            z_hi = z_max - RIDGE_AMP - TWINE_EMBED
+            add_square_wrap(bm, x, y_half, z_lo, z_hi, TWINE_T, TWINE_W, TWINE_IDX)
+            add_rim(
                 bm,
-                (x, 0.0, BALE_Z + TWINE_PAD - TWINE_T / 2.0),
-                (TWINE_W, wrap_y, TWINE_T),
-                TWINE_IDX,
-            )
-            add_box(
-                bm,
-                (x, hy + TWINE_PAD + TWINE_T / 2.0, BALE_Z / 2.0 + 0.004),
-                (TWINE_W, TWINE_T, wrap_z),
-                TWINE_IDX,
-            )
-            add_box(
-                bm,
-                (x, -(hy + TWINE_PAD + TWINE_T / 2.0), BALE_Z / 2.0 + 0.004),
-                (TWINE_W, TWINE_T, wrap_z),
-                TWINE_IDX,
-            )
-            add_box(
-                bm,
-                (x, 0.02, BALE_Z + TWINE_PAD + 0.004),
-                (TWINE_W + 0.008, 0.032, 0.018),
+                (x, 0.0, z_hi + TWINE_T),
+                0.014,
+                0.007,
                 TWINE_IDX,
+                euler=(math.pi / 2.0, 0.0, math.pi / 2.0),
+                n_major=10,
+                n_minor=5,
             )
         twine_faces.update(set(bm.faces) - before)
 
+        bmesh.ops.remove_doubles(bm, verts=list(bm.verts), dist=DOUBLES_EPS)
+
         zs = [v.co.z for v in bm.verts]
         zmin = min(zs)
         xs = [v.co.x for v in bm.verts]
@@ -253,13 +434,33 @@ def build_bale_mesh(name, bevel_offset, bevel_segments):
     return obj
 
 
-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 = 8.0
+        tex.inputs["Roughness"].default_value = 0.55
+        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"])
+        rmix = nt.nodes.new("ShaderNodeMix")
+        rmix.data_type = "FLOAT"
+        rmix.inputs["A"].default_value = roughness
+        rmix.inputs["B"].default_value = min(1.0, roughness + 0.18)
+        rfac = rmix.inputs.get("Factor") or rmix.inputs.get("Fac")
+        nt.links.new(tex.outputs["Fac"], rfac)
+        nt.links.new(rmix.outputs["Result"], bsdf.inputs["Roughness"])
     return mat
 
 
@@ -398,14 +599,32 @@ def export_unity(path, objects):
     )
 
 
-def check(skip_decimate):
+def check(skip_decimate, lift_z=False):
     bpy.ops.wm.read_factory_settings(use_empty=True)
-    low = build_bale_mesh("BaleLow", bevel_offset=0.012, bevel_segments=2)
-    high = build_bale_mesh("BaleHigh", bevel_offset=0.012, bevel_segments=4)
-    hay = principled("BaleHay", (0.72, 0.55, 0.18, 1.0), 0.0, 0.84)
-    twine = principled("BaleTwine", (0.20, 0.14, 0.07, 1.0), 0.0, 0.52)
+    low = build_bale_mesh("BaleLow", bevel_offset=0.016, bevel_segments=2)
+    high = build_bale_mesh("BaleHigh", bevel_offset=0.016, bevel_segments=4)
+    hay = principled(
+        "BaleHay",
+        (0.66, 0.52, 0.18, 1.0),
+        0.0,
+        0.78,
+        noise_scale=22.0,
+        wear=(0.48, 0.36, 0.10, 1.0),
+    )
+    twine = principled(
+        "BaleTwine",
+        (0.22, 0.16, 0.08, 1.0),
+        0.0,
+        0.58,
+        noise_scale=14.0,
+        wear=(0.14, 0.10, 0.05, 1.0),
+    )
     assign_slots(low, hay, twine)
     assign_slots(high, hay, twine)
+    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("hay bale mesh did not build", 3), None, None, None, None, None
@@ -466,10 +685,18 @@ def check(skip_decimate):
         f"measured bbox=({size_x:.4f},{size_y:.4f},{size_z:.4f}) "
         f"outer={OUTER_SIZE} zmin={bb[2]:.4f}"
     )
+    hyg = hygiene_audit(low.data)
+    gap = min_mat_distance(low.data, TWINE_IDX, HAY_IDX)
     print(
         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']} euler={hyg['euler']}"
+    )
+    print(f"measured hay_twine_gap={gap:.5f} zmin={bb[2]:.6f}")
 
     if not (BASE_TRIS_MIN <= base_tris <= BASE_TRIS_MAX):
         return fail(
@@ -534,6 +761,31 @@ 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"]
+    ):
+        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']}",
+            15,
+        ), None, None, None, None, None
+    if abs(bb[2]) > ZMIN_EPS:
+        return fail(
+            f"zmin {bb[2]:.6f} not within {ZMIN_EPS} of 0 "
+            "(--lift-z is the designed fail)",
+            16,
+        ), None, None, None, None, None
+    if gap > GAP_MAX:
+        return fail(
+            f"hay-twine gap {gap:.5f} > {GAP_MAX} (twine must cinch the loaf)",
+            17,
+        ), None, None, None, None, None
     return 0, low, high, hay, tex, collider
 
 
@@ -651,9 +903,14 @@ def main():
         action="store_true",
         help="falsification: skip the LOD DECIMATE stage",
     )
+    p.add_argument(
+        "--lift-z",
+        action="store_true",
+        help="falsification: lift the mesh so zmin fails the grounded budget",
+    )
     args = p.parse_args(argv)
 
-    code, low, _high, hay, tex, _col = check(args.skip_decimate)
+    code, low, _high, hay, tex, _col = check(args.skip_decimate, lift_z=args.lift_z)
     if code:
         return code
     if args.output:
diff --git a/showcase/hay-bale/preview.webp b/showcase/hay-bale/preview.webp
index 8c99ea0..2092fb3 100644
Binary files a/showcase/hay-bale/preview.webp and b/showcase/hay-bale/preview.webp differ
diff --git a/showcase/hitching-post/README.md b/showcase/hitching-post/README.md
index 08866a9..6185bb8 100644
--- a/showcase/hitching-post/README.md
+++ b/showcase/hitching-post/README.md
@@ -1,9 +1,10 @@
 # Hitching post
 
 A showcase piece, not an example. Procedural timber hitching post
-(square post, pyramidal cap, cross-arm, iron shoe, bands, and two
-hitching rings) then the shipped pipeline: unique-cell UVs, Cycles
-high-to-low normal bake, LOD chain, convex collider, Unity glTF export.
+(square post, pyramid cap on the post corners, stub-and-tenon
+cross-arm, iron collar shoe and bands, eye-threaded hitching rings)
+then the shipped pipeline: unique-cell UVs, Cycles high-to-low normal
+bake, LOD chain, convex collider, Unity glTF export.
 
 It asserts **budget conformance** of the generated result. It does not
 witness an API contract. "It rendered without error" is not a check.
@@ -13,6 +14,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: 0.125 m square post, 1.16 m timber plus 0.10 m cap;
+cross-arm 0.46 m; outer AABB 0.460 × 0.191 × 1.258 m.
 
 ## Budgets
 
@@ -21,34 +27,39 @@ materials, UVs, evaluated LOD, collider, or export file.
 
 | Axis | Declared | Measured (4.5.11 / 5.1.2 / 5.2.1) |
 | --- | --- | --- |
-| Base triangles | 780–920 | 848 / 848 / 848 |
-| LOD1 ratio | 0.32–0.62 of base | 0.5000 / 0.5000 / 0.5000 |
-| LOD2 ratio | 0.10–0.35 of base | 0.2193 / 0.2193 / 0.1958 |
-| Materials | exactly 2 distinct, ≥24 metal faces | 2 slots, 262 metal |
+| Base triangles | 900–1800 | 1598 / 1598 / 1598 |
+| LOD1 ratio | 0.32–0.62 of base | 0.4994 / 0.4994 / 0.4994 |
+| LOD2 ratio | 0.10–0.35 of base | 0.2190 / 0.2190 / 0.2190 |
+| Materials | exactly 2 distinct, ≥12 wood, ≥24 metal | 2 slots, 269 wood, 532 metal |
 | UVs | in `0..1`, AABB overlap ≤ 1e-5 | in range, overlap 0 |
-| Outer AABB | (0.460, 0.194, 1.260) m ± 0.01 | (0.4600, 0.1943, 1.2600), zmin 0 |
-| Collider tris | ≤ 180 | 144 |
-| Export | written, size > 0 | 73164 / 73164 / 73160 bytes |
+| Outer AABB | (0.460, 0.191, 1.258) m ± 0.01 | (0.4600, 0.1912, 1.2580) |
+| Grounded zmin | within 1e-4 of 0 | 0 / 0 / 0 |
+| Hygiene | loose/nonman/zero-area/doubles/ngons = 0 | 0 / 0 / 0 |
+| Wood–metal gap | BVH surface < 0.008 m | 0.00045 / 0.00045 / 0.00045 |
+| Collider tris | ≤ 280 | 78 |
+| Export | written, size > 0 | 121496 / 121496 / 121480 bytes |
 
 DECIMATE COLLAPSE triangle counts are **not** identical across series —
-5.2.1 is more aggressive on LOD2. The gate is a ratio band, not an
-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 4 B on 5.2.1 (glTF serializer), not a
-gated axis.
+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
+16 B on 5.2.1 (glTF serializer), not a gated axis. Euler characteristic
+is 10 (multi-body: timber, collars, eyes, rings) — not gated to 2.
 
 `--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.
+exit 9 fires. `--lift-z` raises the mesh 5 cm so the grounded-zmin
+hygiene budget fails and exit 16 fires.
 
 ## Run
 
 ```bash
 blender --background --python hitching_post.py --
 blender --background --python hitching_post.py -- --skip-decimate
+blender --background --python hitching_post.py -- --lift-z
 blender --background --python hitching_post.py -- --output hitching-post.png
 ```
 
-Smoke does not pass `--output` or `--skip-decimate`.
+Smoke does not pass `--output`, `--skip-decimate`, or `--lift-z`.
 
 ## Exit codes
 
@@ -72,3 +83,6 @@ 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: loose verts/edges, non-manifold, zero-area, doubles, or n-gons |
+| 16 | Grounded zmin (`--lift-z` lands here) |
+| 17 | Wood–metal BVH gap above 8 mm |
diff --git a/showcase/hitching-post/hitching_post.py b/showcase/hitching-post/hitching_post.py
index b9edd1e..4d9f839 100644
--- a/showcase/hitching-post/hitching_post.py
+++ b/showcase/hitching-post/hitching_post.py
@@ -8,7 +8,8 @@
 
 Budgets are declared below and recomputed from the generated result.
 They are not API-contract witnesses. ``--skip-decimate`` skips the LOD
-DECIMATE stage so the LOD-ratio budget fails.
+DECIMATE stage so the LOD-ratio budget fails. ``--lift-z`` raises the
+mesh so the grounded-zmin hygiene budget fails.
 
 No RNG. Construction is closed-form. DECIMATE COLLAPSE triangle counts
 are not byte-identical across Blender versions — the LOD gate is a
@@ -16,6 +17,7 @@
 
     blender --background --python hitching_post.py --
     blender --background --python hitching_post.py -- --skip-decimate
+    blender --background --python hitching_post.py -- --lift-z
     blender --background --python hitching_post.py -- --output hitching-post.png
 """
 import argparse
@@ -28,6 +30,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)
@@ -39,22 +42,27 @@
 POST_W = 0.125
 POST_H = 1.16
 CAP_H = 0.10
-SHOE_H = 0.050
-SHOE_SCALE = 1.34
+CAP_EMBED = 0.002
+SHOE_H = 0.055
+SHOE_T = 0.014
+SHOE_SCALE = 1.38
 ARM_Z = 0.90
 ARM_L = 0.46
 ARM_Y = 0.056
 ARM_ZTH = 0.056
-RING_MAJOR = 0.058
-RING_MINOR = 0.011
-BAND_H = 0.030
-BAND_T = 0.012
+TENON_SCALE = 0.62
+RING_MAJOR = 0.052
+RING_MINOR = 0.009
+EYE_MAJOR = 0.015
+EYE_MINOR = 0.005
+BAND_H = 0.028
+BAND_T = 0.010
 BAND_ZS = (0.20, 0.52)
 
 BBOX_TOL = 0.01
-OUTER_SIZE = (0.460, 0.194, 1.260)
-BASE_TRIS_MIN = 780
-BASE_TRIS_MAX = 920
+OUTER_SIZE = (0.460, 0.191, 1.258)
+BASE_TRIS_MIN = 900
+BASE_TRIS_MAX = 1800
 LOD1_RATIO_MIN = 0.32
 LOD1_RATIO_MAX = 0.62
 LOD2_RATIO_MIN = 0.10
@@ -64,11 +72,16 @@
 MATERIAL_COUNT = 2
 UV_EPS = 1e-4
 UV_OVERLAP_MAX = 1e-5
-COLLIDER_TRIS_MAX = 180
+COLLIDER_TRIS_MAX = 280
 BAKE_RES = 256
 CAGE_EXTRUSION = 0.08
 METAL_FACES_MIN = 24
 WOOD_FACES_MIN = 12
+ZMIN_EPS = 1e-4
+DOUBLES_EPS = 1e-5
+AREA_EPS = 1e-10
+GAP_MAX = 0.008
+LIFT_Z = 0.05
 
 WOOD_IDX = 0
 METAL_IDX = 1
@@ -180,19 +193,18 @@ def add_cone(bm, loc, radius1, radius2, depth, segments, mat_idx, euler=(0.0, 0.
     return verts
 
 
-def add_rim(bm, loc, major, minor, mat_idx, euler=(0.0, 0.0, 0.0)):
-    n_major = 14
-    n_minor = 7
+def add_rim(bm, loc, major, minor, mat_idx, euler=(0.0, 0.0, 0.0), n_major=18, n_minor=8):
     rings = []
     for i in range(n_major):
         u = i * (2.0 * math.pi / n_major)
         ring = []
         for j in range(n_minor):
             v = j * (2.0 * math.pi / n_minor)
-            x = (major + minor * math.cos(v)) * math.cos(u)
-            y = (major + minor * math.cos(v)) * math.sin(u)
-            z = minor * math.sin(v)
-            ring.append(bm.verts.new((x, y, z)))
+            ring.append(bm.verts.new((
+                (major + minor * math.cos(v)) * math.cos(u),
+                (major + minor * math.cos(v)) * math.sin(u),
+                minor * math.sin(v),
+            )))
         rings.append(ring)
     bm.verts.ensure_lookup_table()
     for i in range(n_major):
@@ -212,12 +224,120 @@ def add_rim(bm, loc, major, minor, mat_idx, euler=(0.0, 0.0, 0.0)):
 
 
 def add_square_band(bm, z, half, t, h, mat_idx):
-    metal = []
-    metal.extend(add_box(bm, (0.0, half + t / 2.0, z), (2.0 * half + 2.0 * t, t, h), mat_idx))
-    metal.extend(add_box(bm, (0.0, -(half + t / 2.0), z), (2.0 * half + 2.0 * t, t, h), mat_idx))
-    metal.extend(add_box(bm, (half + t / 2.0, 0.0, z), (t, 2.0 * half, h), mat_idx))
-    metal.extend(add_box(bm, (-(half + t / 2.0), 0.0, z), (t, 2.0 * half, h), mat_idx))
-    return metal
+    """Closed square collar in XY, extruded along Z. One manifold torus."""
+    z0 = z - h * 0.5
+    z1 = z + h * 0.5
+    inner = (
+        (half, half),
+        (-half, half),
+        (-half, -half),
+        (half, -half),
+    )
+    outer = (
+        (half + t, half + t),
+        (-(half + t), half + t),
+        (-(half + t), -(half + t)),
+        (half + t, -(half + t)),
+    )
+
+    def ring(zc, pts):
+        return [bm.verts.new((p[0], p[1], zc)) for p in pts]
+
+    i0 = ring(z0, inner)
+    o0 = ring(z0, outer)
+    i1 = ring(z1, inner)
+    o1 = ring(z1, outer)
+
+    def quad(a, b, c, d):
+        face = bm.faces.new((a, b, c, d))
+        face.material_index = mat_idx
+        return face
+
+    for k in range(4):
+        n = (k + 1) % 4
+        quad(i0[k], i0[n], i1[n], i1[k])
+        quad(o0[k], o1[k], o1[n], o0[n])
+        quad(i0[k], o0[k], o0[n], i0[n])
+        quad(i1[k], i1[n], o1[n], o1[k])
+    return i0 + o0 + i1 + o1
+
+
+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):
+    # Combinatorics match examples/mesh-hygiene-audit.audit (copied, not imported).
+    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)
+    areas = [face_area(me, p) for p in me.polygons]
+    zero_area = sum(1 for a in areas if a <= AREA_EPS)
+    bm = bmesh.new()
+    try:
+        bm.from_mesh(me)
+        bm.verts.ensure_lookup_table()
+        bm.edges.ensure_lookup_table()
+        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 min_mat_distance(me, ia, ib):
+    """Closest surface distance between two material islands via BVH."""
+    bm_a = bmesh.new()
+    bm_b = bmesh.new()
+    try:
+        bm_a.from_mesh(me)
+        bm_b.from_mesh(me)
+        bm_a.faces.ensure_lookup_table()
+        bm_b.faces.ensure_lookup_table()
+        drop_a = [f for f in bm_a.faces if f.material_index != ia]
+        drop_b = [f for f in bm_b.faces if f.material_index != ib]
+        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 None:
+                continue
+            best = min(best, hit[3])
+        for f in bm_a.faces:
+            hit = tree.find_nearest(f.calc_center_median())
+            if hit[0] is None:
+                continue
+            best = min(best, hit[3])
+        return best
+    finally:
+        bm_a.free()
+        bm_b.free()
 
 
 def pack_uvs(bm, margin=0.08):
@@ -267,8 +387,8 @@ def build_hitching_post_mesh(name, bevel_offset, bevel_segments):
     bm = bmesh.new()
     try:
         wood = []
-        metal = []
         half = POST_W / 2.0
+        cap_r = half * math.sqrt(2.0)
 
         wood.extend(
             add_box(
@@ -278,29 +398,50 @@ def build_hitching_post_mesh(name, bevel_offset, bevel_segments):
                 WOOD_IDX,
             )
         )
+        # Pyramid whose base vertices land on the post corners, then embed
+        # 2mm so the cap/post plane cannot z-fight.
         wood.extend(
             add_cone(
                 bm,
-                (0.0, 0.0, POST_H + CAP_H / 2.0),
-                POST_W * 0.78,
-                0.012,
+                (0.0, 0.0, POST_H + CAP_H / 2.0 - CAP_EMBED),
+                cap_r,
+                0.008,
                 CAP_H,
                 4,
                 WOOD_IDX,
                 euler=(0.0, 0.0, math.pi / 4.0),
             )
         )
+        stub = ARM_L / 2.0 - half
+        tenon_y = ARM_Y * TENON_SCALE
+        tenon_z = ARM_ZTH * TENON_SCALE
         wood.extend(
             add_box(
                 bm,
                 (0.0, 0.0, ARM_Z),
-                (ARM_L, ARM_Y, ARM_ZTH),
+                (POST_W + 0.012, tenon_y, tenon_z),
+                WOOD_IDX,
+            )
+        )
+        wood.extend(
+            add_box(
+                bm,
+                (half + stub / 2.0, 0.0, ARM_Z),
+                (stub, ARM_Y, ARM_ZTH),
+                WOOD_IDX,
+            )
+        )
+        wood.extend(
+            add_box(
+                bm,
+                (-(half + stub / 2.0), 0.0, ARM_Z),
+                (stub, ARM_Y, ARM_ZTH),
                 WOOD_IDX,
             )
         )
 
         if bevel_offset > 0.0:
-            edges = list({e for v in wood for e in v.link_edges})
+            edges = list({e for v in wood for e in v.link_edges if v.is_valid})
             ret = bmesh.ops.bevel(
                 bm,
                 geom=edges,
@@ -313,38 +454,46 @@ def build_hitching_post_mesh(name, bevel_offset, bevel_segments):
             for f in ret.get("faces") or []:
                 f.material_index = WOOD_IDX
 
-        metal.extend(
-            add_box(
-                bm,
-                (0.0, 0.0, SHOE_H / 2.0),
-                (POST_W * SHOE_SCALE, POST_W * SHOE_SCALE, SHOE_H),
-                METAL_IDX,
-            )
-        )
+        # Shoe is a collar whose inner faces sit on the post, not a solid plate
+        # the post punches through.
+        add_square_band(bm, SHOE_H / 2.0, half - 0.002, SHOE_T, SHOE_H, METAL_IDX)
         for z in BAND_ZS:
-            metal.extend(add_square_band(bm, z, half, BAND_T, BAND_H, METAL_IDX))
+            add_square_band(bm, z, half - 0.002, BAND_T, BAND_H, METAL_IDX)
 
-        ring_y = -(max(POST_W, ARM_Y) / 2.0 + RING_MINOR + 0.006)
+        arm_y_face = -(ARM_Y / 2.0)
         for sx in (-ARM_L * 0.32, ARM_L * 0.32):
-            metal.extend(
-                add_box(
-                    bm,
-                    (sx, ring_y + RING_MINOR + 0.010, ARM_Z),
-                    (0.018, 0.022, 0.018),
-                    METAL_IDX,
-                )
+            # Eye on the -Y arm face; hitching ring threads it (YZ vs XZ).
+            add_rim(
+                bm,
+                (sx, arm_y_face + EYE_MINOR * 0.25, ARM_Z),
+                EYE_MAJOR,
+                EYE_MINOR,
+                METAL_IDX,
+                euler=(math.pi / 2.0, 0.0, 0.0),
+                n_major=14,
+                n_minor=7,
             )
-            metal.extend(
-                add_rim(
-                    bm,
-                    (sx, ring_y - RING_MAJOR * 0.35, ARM_Z - RING_MAJOR * 0.15),
-                    RING_MAJOR,
-                    RING_MINOR,
-                    METAL_IDX,
-                    euler=(math.pi / 2.0, 0.0, 0.0),
-                )
+            add_rim(
+                bm,
+                (
+                    sx,
+                    arm_y_face - RING_MAJOR * 0.55,
+                    ARM_Z - RING_MAJOR * 0.28,
+                ),
+                RING_MAJOR,
+                RING_MINOR,
+                METAL_IDX,
+                euler=(0.0, math.pi / 2.0, 0.0),
+                n_major=18,
+                n_minor=8,
             )
 
+        bmesh.ops.remove_doubles(bm, verts=list(bm.verts), dist=DOUBLES_EPS)
+        bm.faces.ensure_lookup_table()
+        degen = [f for f in bm.faces if f.calc_area() <= AREA_EPS]
+        if degen:
+            bmesh.ops.delete(bm, geom=degen, context="FACES")
+
         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]
@@ -361,12 +510,20 @@ def build_hitching_post_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
+            if face.material_index == METAL_IDX:
+                face.smooth = True
+            else:
+                face.smooth = False
+        for edge in bm.edges:
+            if not edge.is_manifold or len(edge.link_faces) != 2:
+                continue
+            if edge.calc_face_angle() > math.radians(35.0):
+                edge.smooth = False
         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)
@@ -374,13 +531,25 @@ def build_hitching_post_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
 
 
@@ -513,14 +682,25 @@ def export_unity(path, objects):
     )
 
 
-def check(skip_decimate):
+def check(skip_decimate, lift_z=False):
     bpy.ops.wm.read_factory_settings(use_empty=True)
-    low = build_hitching_post_mesh("HitchPostLow", bevel_offset=0.004, bevel_segments=2)
-    high = build_hitching_post_mesh("HitchPostHigh", bevel_offset=0.004, bevel_segments=4)
-    wood = principled("HitchPostWood", (0.36, 0.19, 0.07, 1.0), 0.0, 0.60)
-    metal = principled("HitchPostIron", (0.14, 0.145, 0.155, 1.0), 1.0, 0.38)
+    low = build_hitching_post_mesh("HitchPostLow", bevel_offset=0.008, bevel_segments=2)
+    high = build_hitching_post_mesh("HitchPostHigh", bevel_offset=0.008, bevel_segments=4)
+    wood = principled(
+        "HitchPostWood",
+        (0.36, 0.19, 0.07, 1.0),
+        0.0,
+        0.62,
+        noise_scale=11.0,
+        wear=(0.24, 0.13, 0.05, 1.0),
+    )
+    metal = principled("HitchPostIron", (0.12, 0.125, 0.135, 1.0), 1.0, 0.42)
     assign_slots(low, wood, metal)
     assign_slots(high, wood, metal)
+    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("hitching post mesh did not build", 3), None, None, None, None, None
@@ -581,10 +761,18 @@ def check(skip_decimate):
         f"measured bbox=({size_x:.4f},{size_y:.4f},{size_z:.4f}) "
         f"outer={OUTER_SIZE} zmin={bb[2]:.4f}"
     )
+    hyg = hygiene_audit(low.data)
+    gap = min_mat_distance(low.data, METAL_IDX, WOOD_IDX)
     print(
         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']} euler={hyg['euler']}"
+    )
+    print(f"measured wood_metal_gap={gap:.5f} zmin={bb[2]:.6f}")
 
     if not (BASE_TRIS_MIN <= base_tris <= BASE_TRIS_MAX):
         return fail(
@@ -649,6 +837,31 @@ 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"]
+    ):
+        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']}",
+            15,
+        ), None, None, None, None, None
+    if abs(bb[2]) > ZMIN_EPS:
+        return fail(
+            f"zmin {bb[2]:.6f} not within {ZMIN_EPS} of 0 "
+            "(--lift-z is the designed fail)",
+            16,
+        ), None, None, None, None, None
+    if gap > GAP_MAX:
+        return fail(
+            f"wood-metal gap {gap:.5f} > {GAP_MAX}",
+            17,
+        ), None, None, None, None, None
     return 0, low, high, wood, tex, collider
 
 
@@ -767,9 +980,14 @@ def main():
         action="store_true",
         help="falsification: skip the LOD DECIMATE stage",
     )
+    p.add_argument(
+        "--lift-z",
+        action="store_true",
+        help="falsification: lift the mesh so zmin fails the grounded budget",
+    )
     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)
     if code:
         return code
     if args.output:
diff --git a/showcase/hitching-post/preview.webp b/showcase/hitching-post/preview.webp
index 1223411..39d5d78 100644
Binary files a/showcase/hitching-post/preview.webp and b/showcase/hitching-post/preview.webp differ