diff --git a/docs/gallery/assets/hitching-post-hero.webp b/docs/gallery/assets/hitching-post-hero.webp
index 39d5d78f..6954d2a8 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/assets/wooden-ladder-hero.webp b/docs/gallery/assets/wooden-ladder-hero.webp
index c758379d..2b6c2c42 100644
Binary files a/docs/gallery/assets/wooden-ladder-hero.webp and b/docs/gallery/assets/wooden-ladder-hero.webp differ
diff --git a/docs/gallery/hitching-post/index.html b/docs/gallery/hitching-post/index.html
index 0aab17a1..33bc032f 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 (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="description" content="A procedural hitching post (eaved cap, one rail, cup shoe, rings hung through eyes) 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 (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:description" content="A procedural hitching post (eaved cap, one rail, cup shoe, rings hung through eyes) 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 (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:description" content="A procedural hitching post (eaved cap, one rail, cup shoe, rings hung through eyes) 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,37 +246,44 @@
   </div>
   <header class="hero">
     <h1>hitching-post</h1>
-    <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>
+    <p>A procedural hitching post (eaved cap, one rail, cup shoe, rings hung through eyes) 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: 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="callout"><span class="tag">witnesses</span> Recomputed: 1680 tris, two materials with 114 wood and 742 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.500×0.149×1.246 m, zmin 0, hygiene and coplanar pairs 0, post seated at z 0.010, ring centerline error 0, LOD ratios in band, convex collider 80 tris, non-empty glTF. --skip-decimate exits 9; --stray-vert and --twin-sole exit 15; --lift-z exits 16; --clip-ring exits 18; --short-post exits 19.</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, 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>A showcase piece, not an example. Procedural timber hitching post: a 125 mm square post seated in a closed iron shoe, one cross-rail through the post, a pyramidal cap with eaves, and two rings hung through eyes under the rail. 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). 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>
+<p>Intended size: post 0.125 m square and 1.16 m of timber, cap 0.096 m, cross-rail 0.50 m. Outer AABB 0.500 × 0.149 × 1.246 m.</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). Coplanar-pair counting matches <code>showcase/signpost</code>.</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 | 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>
+<p>| Axis | Declared | Measured (4.5.11 / 5.1.2 / 5.2.1) | | --- | --- | --- | | Base triangles | 1400–2400 | 1680 / 1680 / 1680 | | LOD1 ratio | 0.32–0.62 of base | 0.5000 / 0.5000 / 0.5000 | | LOD2 ratio | 0.10–0.35 of base | 0.2190 / 0.2190 / 0.2190 | | Materials | exactly 2 distinct, ≥70 wood, ≥560 metal | 2 slots, 114 wood, 742 metal | | UVs | in <code>0..1</code>, AABB overlap ≤ 1e-5 | in range, overlap 0 | | Outer AABB | (0.500, 0.149, 1.246) m ± 0.01 | (0.5000, 0.1490, 1.2460) | | Grounded zmin | within 1e-4 of 0 | 0 / 0 / 0 | | Hygiene | loose/nonman/zero-area/doubles/n-gons/coplanar pairs = 0 | all 0 | | Post seat | world zmin in (0.004, 0.014), XY centroid within 0.010 of origin, arm axis cos ≥ cos(0.5°) | 0.01000, 0, 1.000 | | Hung ring | centerline error ≤ 0.008 m, ring–wood overlap 0, eye–wood overlap 0, shank–ring overlap 0, shank bites the eye | 0, 0, 0, 0, 40 | | Shoe | each band overlaps the post, shoe overlaps the sole | band gap 0, sole–shoe 8 | | Wood–metal gap | BVH surface &lt; 0.008 m | 0.00075 | | Collider tris | ≤ 280 | 80 | | Export | written, size &gt; 0 | 127428 / 127428 / 127412 bytes |</p>
+<p>Base triangles rose from <strong>1598 to 1680</strong>. The old rings were faceted tori clipped into the arm; the new eyes, shanks, and 24-segment hung rings replace that mesh. Cylinder caps are triangulated so the n-gon budget stays at 0.</p>
+<p>DECIMATE COLLAPSE triangle counts are <strong>not</strong> identical across series — the gate is a ratio band, not an exact count. On this mesh the three binaries agreed. 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 is 12 (six balls and seven tori) and is not gated to 2.</p>
+<p>Each falsifier violates exactly one named budget. Proven on Blender 4.5.11 LTS, 5.1.2, and 5.2.1 LTS (the binaries&#x27; own <code>--version</code>):</p>
+<p>| Falsifier | Budget violated | Exit | Measured failure | | --- | --- | --- | --- | | <code>--skip-decimate</code> | LOD1 ratio band | 9 | ratio 1.0000 | | <code>--stray-vert</code> | Mesh hygiene, loose verts | 15 | <code>loose_v=1</code> | | <code>--twin-sole</code> | Coplanar face pairs | 15 | <code>zfight=6</code> | | <code>--lift-z</code> | Grounded zmin | 16 | zmin 0.050000 | | <code>--clip-ring</code> | Hung-ring centerline | 18 | ring_err 0.024, ring–wood overlap 32 | | <code>--short-post</code> | Seated post | 19 | post zmin 0.030 |</p>
+<p>Default exit is 0 on all three. <code>--clip-ring</code> also overlaps the rail; the centerline gate is the one that 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 -- --stray-vert
+blender --background --python hitching_post.py -- --twin-sole
 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>, <code>--skip-decimate</code>, or <code>--lift-z</code>.</p>
+blender --background --python hitching_post.py -- --clip-ring
+blender --background --python hitching_post.py -- --short-post
+blender --background --python hitching_post.py -- --output preview.webp --engine cycles</code></pre>
+<p>Smoke does not pass <code>--output</code> or a falsifier.</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 | | 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>
+<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, including coplanar pairs (<code>--stray-vert</code>, <code>--twin-sole</code>) | | 16 | Grounded zmin (<code>--lift-z</code>) | | 17 | Wood–metal BVH gap above 8 mm | | 18 | Hung ring or shoe seat (<code>--clip-ring</code>) | | 19 | Post plumb, origin, and cup seat (<code>--short-post</code>) |</p>
     </section>
     <section class="detail-section src">
       <h2>Source</h2>
@@ -295,7 +302,11 @@ <h2>Source</h2>
 Budgets are declared below and recomputed from the generated result.
 They are not API-contract witnesses. ``--skip-decimate`` skips the LOD
 DECIMATE stage so the LOD-ratio budget fails. ``--lift-z`` raises the
-mesh so the grounded-zmin hygiene budget fails.
+mesh so the grounded-zmin budget fails. ``--stray-vert`` adds one loose
+vertex so the hygiene budget fails. ``--twin-sole`` duplicates the shoe
+plate so the coplanar-face budget fails. ``--clip-ring`` lifts a hung
+ring off the eye centerline. ``--short-post`` starts the post above the
+shoe cup so the seated-post budget fails.
 
 No RNG. Construction is closed-form. DECIMATE COLLAPSE triangle counts
 are not byte-identical across Blender versions — the LOD gate is a
@@ -304,6 +315,10 @@ <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 -- --stray-vert
+    blender --background --python hitching_post.py -- --twin-sole
+    blender --background --python hitching_post.py -- --clip-ring
+    blender --background --python hitching_post.py -- --short-post
     blender --background --python hitching_post.py -- --output hitching-post.png
 &quot;&quot;&quot;</span>
 <span class="k">import</span> argparse
@@ -327,28 +342,37 @@ <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>
-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>
+CAP_H = <span class="n">0.096</span>
+CAP_OVERHANG = <span class="n">0.010</span>
+CAP_EMBED = <span class="n">0.010</span>
+SOLE_T = <span class="n">0.016</span>
+POST_BITE = <span class="n">0.006</span>
+SHOE_H = <span class="n">0.064</span>
+SHOE_T = <span class="n">0.012</span>
+ARM_Z = <span class="n">0.88</span>
+ARM_L = <span class="n">0.50</span>
 ARM_Y = <span class="n">0.056</span>
-ARM_ZTH = <span class="n">0.056</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>)
+ARM_ZTH = <span class="n">0.050</span>
+EYE_MAJOR = <span class="n">0.016</span>
+EYE_MINOR = <span class="n">0.0045</span>
+RING_MAJOR = <span class="n">0.038</span>
+RING_MINOR = <span class="n">0.0065</span>
+EYE_X = <span class="n">0.162</span>
+BAND_H = <span class="n">0.026</span>
+BAND_T = <span class="n">0.008</span>
+BAND_ZS = (<span class="n">0.24</span>, <span class="n">0.56</span>)
+<span class="c"># Ring tube must fit through the eye: RING_MINOR &lt; EYE_MAJOR - EYE_MINOR.</span>
+RING_FIT = <span class="n">0.004</span>
+POST_ZMIN_LO = <span class="n">0.004</span>
+POST_ZMIN_HI = <span class="n">0.014</span>
+RING_CENTER_TOL = <span class="n">0.008</span>
+AXIS_COS_MIN = math.cos(math.radians(<span class="n">0.5</span>))
+POST_XY_MAX = <span class="n">0.010</span>
 
 BBOX_TOL = <span class="n">0.01</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>
+OUTER_SIZE = (<span class="n">0.500</span>, <span class="n">0.149</span>, <span class="n">1.246</span>)
+BASE_TRIS_MIN = <span class="n">1400</span>
+BASE_TRIS_MAX = <span class="n">2400</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>
@@ -361,11 +385,13 @@ <h2>Source</h2>
 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>
+METAL_FACES_MIN = <span class="n">560</span>
+WOOD_FACES_MIN = <span class="n">70</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>
+ZFIGHT_EPS = <span class="n">0.002</span>
+ZFIGHT_COS = <span class="n">0.98</span>
 GAP_MAX = <span class="n">0.008</span>
 LIFT_Z = <span class="n">0.05</span>
 
@@ -441,7 +467,7 @@ <h2>Source</h2>
     geo = bmesh.ops.create_cone(
         bm,
         cap_ends=<span class="k">True</span>,
-        cap_tris=<span class="k">False</span>,
+        cap_tris=<span class="k">True</span>,
         segments=segments,
         radius1=radius,
         radius2=radius,
@@ -591,6 +617,241 @@ <h2>Source</h2>
     }
 
 
+<span class="k">def</span> zfight_pairs(me):
+    <span class="c"># Same pair test as showcase/signpost (copied, not imported).</span>
+    data = [
+        (p.center.copy(), p.normal.copy(), frozenset(p.vertices))
+        <span class="k">for</span> p <span class="k">in</span> me.polygons
+    ]
+    eps2 = ZFIGHT_EPS * ZFIGHT_EPS
+    count = <span class="n">0</span>
+    <span class="k">for</span> i <span class="k">in</span> range(len(data)):
+        ci, ni, vi = data[i]
+        <span class="k">for</span> j <span class="k">in</span> range(i + <span class="n">1</span>, len(data)):
+            cj, nj, vj = data[j]
+            <span class="k">if</span> (cj - ci).length_squared &gt; eps2:
+                <span class="k">continue</span>
+            <span class="k">if</span> abs(ni.dot(nj)) &lt;= ZFIGHT_COS:
+                <span class="k">continue</span>
+            <span class="k">if</span> vi &amp; vj:
+                <span class="k">continue</span>
+            count += <span class="n">1</span>
+    <span class="k">return</span> count
+
+
+<span class="k">def</span> _face_shells(me):
+    parent = list(range(len(me.vertices)))
+
+    <span class="k">def</span> find(a):
+        <span class="k">while</span> parent[a] != a:
+            parent[a] = parent[parent[a]]
+            a = parent[a]
+        <span class="k">return</span> a
+
+    <span class="k">def</span> union(a, b):
+        ra, rb = find(a), find(b)
+        <span class="k">if</span> ra != rb:
+            parent[rb] = ra
+
+    <span class="k">for</span> edge <span class="k">in</span> me.edges:
+        union(int(edge.vertices[<span class="n">0</span>]), int(edge.vertices[<span class="n">1</span>]))
+    groups = {}
+    <span class="k">for</span> i <span class="k">in</span> range(len(me.vertices)):
+        groups.setdefault(find(i), []).append(i)
+    shells = []
+    <span class="k">for</span> idxs <span class="k">in</span> groups.values():
+        want = set(idxs)
+        polys = [
+            p.index
+            <span class="k">for</span> p <span class="k">in</span> me.polygons
+            <span class="k">if</span> all(v <span class="k">in</span> want <span class="k">for</span> v <span class="k">in</span> p.vertices)
+        ]
+        <span class="k">if</span> polys:
+            shells.append((idxs, polys))
+    <span class="k">return</span> shells
+
+
+<span class="k">def</span> _bounds(me, idxs):
+    xs, ys, zs = [], [], []
+    <span class="k">for</span> i <span class="k">in</span> idxs:
+        co = me.vertices[i].co
+        xs.append(co.x)
+        ys.append(co.y)
+        zs.append(co.z)
+    <span class="k">return</span> min(xs), max(xs), min(ys), max(ys), min(zs), max(zs)
+
+
+<span class="k">def</span> _centroid(me, idxs):
+    acc = Vector()
+    <span class="k">for</span> i <span class="k">in</span> idxs:
+        acc += me.vertices[i].co
+    <span class="k">return</span> acc / float(len(idxs))
+
+
+<span class="k">def</span> _majority_mat(me, poly_ids):
+    counts = {}
+    <span class="k">for</span> i <span class="k">in</span> poly_ids:
+        mat = me.polygons[i].material_index
+        counts[mat] = counts.get(mat, <span class="n">0</span>) + <span class="n">1</span>
+    <span class="k">return</span> max(counts, key=counts.get)
+
+
+<span class="k">def</span> _bvh(me, poly_ids):
+    remap = {}
+    verts = []
+    faces = []
+    <span class="k">for</span> pi <span class="k">in</span> poly_ids:
+        face = []
+        <span class="k">for</span> vi <span class="k">in</span> me.polygons[pi].vertices:
+            <span class="k">if</span> vi <span class="k">not</span> <span class="k">in</span> remap:
+                remap[vi] = len(verts)
+                verts.append(me.vertices[vi].co.copy())
+            face.append(remap[vi])
+        faces.append(face)
+    <span class="k">return</span> BVHTree.FromPolygons(verts, faces)
+
+
+<span class="k">def</span> seat_audit(me):
+    <span class="s">&quot;&quot;&quot;Recompute cup, hung-ring, and plumb budgets from the generated shells.&quot;&quot;&quot;</span>
+    post = arm = cap = <span class="k">None</span>
+    soles, rings, eyes, bands, shanks = [], [], [], [], []
+    <span class="k">for</span> idxs, polys <span class="k">in</span> _face_shells(me):
+        x0, x1, y0, y1, z0, z1 = _bounds(me, idxs)
+        dx, dy, dz = x1 - x0, y1 - y0, z1 - z0
+        rec = {
+            <span class="s">&quot;idxs&quot;</span>: idxs,
+            <span class="s">&quot;polys&quot;</span>: polys,
+            <span class="s">&quot;c&quot;</span>: _centroid(me, idxs),
+            <span class="s">&quot;z0&quot;</span>: z0,
+        }
+        <span class="k">if</span> _majority_mat(me, polys) == WOOD_IDX:
+            <span class="k">if</span> dz &gt; <span class="n">0.5</span> <span class="k">and</span> dx &lt; <span class="n">0.30</span>:
+                post = rec
+            <span class="k">elif</span> dx &gt; <span class="n">0.30</span>:
+                arm = rec
+            <span class="k">else</span>:
+                cap = rec
+            <span class="k">continue</span>
+        <span class="k">if</span> z0 &lt; <span class="n">0.004</span> <span class="k">and</span> dz &lt; <span class="n">0.030</span> <span class="k">and</span> dx &gt; <span class="n">0.10</span>:
+            soles.append(rec)
+        <span class="k">elif</span> dy &lt; <span class="n">0.025</span> <span class="k">and</span> dx &gt; <span class="n">0.06</span> <span class="k">and</span> dz &gt; <span class="n">0.06</span>:
+            rings.append(rec)
+        <span class="k">elif</span> dx &lt; <span class="n">0.025</span> <span class="k">and</span> dy &gt; <span class="n">0.025</span> <span class="k">and</span> dz &gt; <span class="n">0.02</span>:
+            eyes.append(rec)
+        <span class="k">elif</span> dx &lt; <span class="n">0.030</span> <span class="k">and</span> dy &lt; <span class="n">0.030</span> <span class="k">and</span> dz &lt; <span class="n">0.08</span>:
+            shanks.append(rec)
+        <span class="k">else</span>:
+            bands.append(rec)
+
+    out = {
+        <span class="s">&quot;post&quot;</span>: int(post <span class="k">is</span> <span class="k">not</span> <span class="k">None</span>),
+        <span class="s">&quot;arm&quot;</span>: int(arm <span class="k">is</span> <span class="k">not</span> <span class="k">None</span>),
+        <span class="s">&quot;cap&quot;</span>: int(cap <span class="k">is</span> <span class="k">not</span> <span class="k">None</span>),
+        <span class="s">&quot;soles&quot;</span>: len(soles),
+        <span class="s">&quot;rings&quot;</span>: len(rings),
+        <span class="s">&quot;eyes&quot;</span>: len(eyes),
+        <span class="s">&quot;bands&quot;</span>: len(bands),
+        <span class="s">&quot;post_zmin&quot;</span>: -<span class="n">1.0</span>,
+        <span class="s">&quot;post_xy&quot;</span>: <span class="n">99.0</span>,
+        <span class="s">&quot;arm_cos&quot;</span>: <span class="n">0.0</span>,
+        <span class="s">&quot;ring_err&quot;</span>: <span class="n">99.0</span>,
+        <span class="s">&quot;ring_wood&quot;</span>: <span class="n">99</span>,
+        <span class="s">&quot;eye_wood&quot;</span>: <span class="n">99</span>,
+        <span class="s">&quot;band_gap&quot;</span>: <span class="n">99.0</span>,
+        <span class="s">&quot;sole_shoe&quot;</span>: <span class="n">0</span>,
+        <span class="s">&quot;shanks&quot;</span>: <span class="n">0</span>,
+        <span class="s">&quot;shank_ring&quot;</span>: <span class="n">99</span>,
+        <span class="s">&quot;shank_eye&quot;</span>: <span class="n">0</span>,
+    }
+    <span class="k">if</span> (
+        post <span class="k">is</span> <span class="k">None</span>
+        <span class="k">or</span> arm <span class="k">is</span> <span class="k">None</span>
+        <span class="k">or</span> cap <span class="k">is</span> <span class="k">None</span>
+        <span class="k">or</span> len(rings) != <span class="n">2</span>
+        <span class="k">or</span> len(eyes) != <span class="n">2</span>
+        <span class="k">or</span> len(bands) &lt; <span class="n">3</span>
+        <span class="k">or</span> len(shanks) != <span class="n">2</span>
+        <span class="k">or</span> <span class="k">not</span> soles
+    ):
+        <span class="k">return</span> out
+
+    wood_bvh = _bvh(me, post[<span class="s">&quot;polys&quot;</span>] + arm[<span class="s">&quot;polys&quot;</span>] + cap[<span class="s">&quot;polys&quot;</span>])
+    ring_wood = <span class="n">0</span>
+    eye_wood = <span class="n">0</span>
+    ring_err = <span class="n">0.0</span>
+    <span class="k">for</span> eye, ring <span class="k">in</span> zip(
+        sorted(eyes, key=<span class="k">lambda</span> r: r[<span class="s">&quot;c&quot;</span>].x),
+        sorted(rings, key=<span class="k">lambda</span> r: r[<span class="s">&quot;c&quot;</span>].x),
+    ):
+        ring_err = max(ring_err, abs((ring[<span class="s">&quot;c&quot;</span>] - eye[<span class="s">&quot;c&quot;</span>]).length - RING_MAJOR))
+        ring_wood += len(wood_bvh.overlap(_bvh(me, ring[<span class="s">&quot;polys&quot;</span>])))
+        eye_wood += len(wood_bvh.overlap(_bvh(me, eye[<span class="s">&quot;polys&quot;</span>])))
+
+    shank_ring = <span class="n">0</span>
+    shank_eye = <span class="n">0</span>
+    <span class="k">for</span> shank <span class="k">in</span> shanks:
+        shank_bvh = _bvh(me, shank[<span class="s">&quot;polys&quot;</span>])
+        <span class="k">for</span> ring <span class="k">in</span> rings:
+            shank_ring += len(shank_bvh.overlap(_bvh(me, ring[<span class="s">&quot;polys&quot;</span>])))
+        eye = min(eyes, key=<span class="k">lambda</span> rec: abs(rec[<span class="s">&quot;c&quot;</span>].x - shank[<span class="s">&quot;c&quot;</span>].x))
+        shank_eye += len(shank_bvh.overlap(_bvh(me, eye[<span class="s">&quot;polys&quot;</span>])))
+
+    band_gap = <span class="n">0.0</span>
+    <span class="k">for</span> band <span class="k">in</span> bands:
+        <span class="k">if</span> wood_bvh.overlap(_bvh(me, band[<span class="s">&quot;polys&quot;</span>])):
+            <span class="k">continue</span>
+        dmin = <span class="n">1.0e9</span>
+        <span class="k">for</span> i <span class="k">in</span> band[<span class="s">&quot;idxs&quot;</span>]:
+            hit = wood_bvh.find_nearest(me.vertices[i].co)
+            <span class="k">if</span> hit[<span class="n">3</span>] <span class="k">is</span> <span class="k">not</span> <span class="k">None</span>:
+                dmin = min(dmin, hit[<span class="n">3</span>])
+        band_gap = max(band_gap, dmin)
+
+    shoe = min(bands, key=<span class="k">lambda</span> b: b[<span class="s">&quot;z0&quot;</span>])
+    sole_shoe = len(_bvh(me, soles[<span class="n">0</span>][<span class="s">&quot;polys&quot;</span>]).overlap(_bvh(me, shoe[<span class="s">&quot;polys&quot;</span>])))
+
+    pos, neg = [], []
+    <span class="k">for</span> i <span class="k">in</span> arm[<span class="s">&quot;idxs&quot;</span>]:
+        co = me.vertices[i].co
+        <span class="k">if</span> co.x &gt; <span class="n">0.12</span>:
+            pos.append(co)
+        <span class="k">elif</span> co.x &lt; -<span class="n">0.12</span>:
+            neg.append(co)
+    <span class="k">if</span> pos <span class="k">and</span> neg:
+        a = sum(pos, Vector()) / len(pos)
+        b = sum(neg, Vector()) / len(neg)
+        arm_cos = abs((a - b).normalized().dot(Vector((<span class="n">1.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>))))
+    <span class="k">else</span>:
+        arm_cos = <span class="n">0.0</span>
+
+    out.update({
+        <span class="s">&quot;post_zmin&quot;</span>: post[<span class="s">&quot;z0&quot;</span>],
+        <span class="s">&quot;post_xy&quot;</span>: math.hypot(post[<span class="s">&quot;c&quot;</span>].x, post[<span class="s">&quot;c&quot;</span>].y),
+        <span class="s">&quot;arm_cos&quot;</span>: arm_cos,
+        <span class="s">&quot;ring_err&quot;</span>: ring_err,
+        <span class="s">&quot;ring_wood&quot;</span>: ring_wood,
+        <span class="s">&quot;eye_wood&quot;</span>: eye_wood,
+        <span class="s">&quot;band_gap&quot;</span>: band_gap,
+        <span class="s">&quot;sole_shoe&quot;</span>: sole_shoe,
+        <span class="s">&quot;shanks&quot;</span>: len(shanks),
+        <span class="s">&quot;shank_ring&quot;</span>: shank_ring,
+        <span class="s">&quot;shank_eye&quot;</span>: shank_eye,
+    })
+    <span class="k">return</span> out
+
+
+<span class="k">def</span> add_stray_vert(me):
+    <span class="c"># Inside the post so the bbox budget still passes and hygiene is the gate.</span>
+    bm = bmesh.new()
+    <span class="k">try</span>:
+        bm.from_mesh(me)
+        bm.verts.new((<span class="n">0.0</span>, <span class="n">0.0</span>, POST_H * <span class="n">0.5</span>))
+        bm.to_mesh(me)
+        me.update()
+    <span class="k">finally</span>:
+        bm.free()
+
+
 <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()
@@ -669,63 +930,71 @@ <h2>Source</h2>
             )
 
 
-<span class="k">def</span> build_hitching_post_mesh(name, bevel_offset, bevel_segments):
+<span class="k">def</span> add_torus(bm, center, major, minor, axis, mat_idx, n_major=<span class="n">24</span>, n_minor=<span class="n">8</span>):
+    <span class="s">&quot;&quot;&quot;Torus whose hole points along `axis`. The loop lies in the perpendicular plane.&quot;&quot;&quot;</span>
+    axis = Vector(axis).normalized()
+    tmp = Vector((<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">1.0</span>)) <span class="k">if</span> abs(axis.z) &lt; <span class="n">0.85</span> <span class="k">else</span> Vector((<span class="n">1.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>))
+    u = axis.cross(tmp).normalized()
+    v = axis.cross(u).normalized()
+    origin = Vector(center)
+    rings = []
+    <span class="k">for</span> i <span class="k">in</span> range(n_major):
+        a = i * (<span class="n">2.0</span> * math.pi / n_major)
+        radial = u * math.cos(a) + v * math.sin(a)
+        ring = []
+        <span class="k">for</span> j <span class="k">in</span> range(n_minor):
+            b = j * (<span class="n">2.0</span> * math.pi / n_minor)
+            point = origin + radial * (major + minor * math.cos(b)) + axis * (minor * math.sin(b))
+            ring.append(bm.verts.new(point))
+        rings.append(ring)
+    bm.verts.ensure_lookup_table()
+    made = []
+    <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
+            made.append(rings[i][j])
+    <span class="k">return</span> made
+
+
+<span class="k">def</span> build_hitching_post_mesh(
+    name,
+    bevel_offset,
+    bevel_segments,
+    short_post=<span class="k">False</span>,
+    clip_ring=<span class="k">False</span>,
+    twin_sole=<span class="k">False</span>,
+    small_cap=<span class="k">False</span>,
+):
+    <span class="s">&quot;&quot;&quot;Post on a closed shoe, one rail, rings hung through eyes under the rail.
+
+    The ring center is the eye center plus (0, 0, -RING_MAJOR), so the eye
+    sits on the ring centerline. The eye hangs below the rail; the shank
+    is bitten into the rail.
+    &quot;&quot;&quot;</span>
     bm = bmesh.new()
     <span class="k">try</span>:
+        half = POST_W * <span class="n">0.5</span>
+        post_z0 = (SOLE_T + <span class="n">0.014</span>) <span class="k">if</span> short_post <span class="k">else</span> (SOLE_T - POST_BITE)
         wood = []
-        half = POST_W / <span class="n">2.0</span>
-        cap_r = half * math.sqrt(<span class="n">2.0</span>)
-
         wood.extend(
             add_box(
                 bm,
-                (<span class="n">0.0</span>, <span class="n">0.0</span>, POST_H / <span class="n">2.0</span>),
-                (POST_W, POST_W, POST_H),
-                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> - CAP_EMBED),
-                cap_r,
-                <span class="n">0.008</span>,
-                CAP_H,
-                <span class="n">4</span>,
+                (<span class="n">0.0</span>, <span class="n">0.0</span>, (post_z0 + POST_H) * <span class="n">0.5</span>),
+                (POST_W, POST_W, POST_H - post_z0),
                 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),
-                (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),
+                (ARM_L, 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 <span class="k">if</span> v.is_valid})
             ret = bmesh.ops.bevel(
@@ -737,58 +1006,90 @@ <h2>Source</h2>
                 affect=<span class="s">&quot;EDGES&quot;</span>,
                 clamp_overlap=<span class="k">True</span>,
             )
-            <span class="k">for</span> f <span class="k">in</span> ret.get(<span class="s">&quot;faces&quot;</span>) <span class="k">or</span> []:
-                f.material_index = WOOD_IDX
+            <span class="k">for</span> face <span class="k">in</span> ret.get(<span class="s">&quot;faces&quot;</span>) <span class="k">or</span> []:
+                face.material_index = WOOD_IDX
+
+        cap_r = (half * <span class="n">0.55</span>) <span class="k">if</span> small_cap <span class="k">else</span> (half + CAP_OVERHANG) * math.sqrt(<span class="n">2.0</span>)
+        add_cone(
+            bm,
+            (<span class="n">0.0</span>, <span class="n">0.0</span>, POST_H + CAP_H * <span class="n">0.5</span> - CAP_EMBED),
+            cap_r,
+            <span class="n">0.004</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>),
+        )
 
-        <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)
+        grip = bevel_offset + <span class="n">0.0015</span>
+        sole_w = POST_W + <span class="n">2.0</span> * SHOE_T
+        add_box(
+            bm,
+            (<span class="n">0.0</span>, <span class="n">0.0</span>, SOLE_T * <span class="n">0.5</span>),
+            (sole_w, sole_w, SOLE_T),
+            METAL_IDX,
+        )
+        <span class="k">if</span> twin_sole:
+            add_box(
+                bm,
+                (<span class="n">0.0012</span>, <span class="n">0.0012</span>, SOLE_T * <span class="n">0.5</span>),
+                (sole_w, sole_w, SOLE_T),
+                METAL_IDX,
+            )
+        wall_z0 = SOLE_T - <span class="n">0.003</span>
+        wall_z1 = SHOE_H
+        add_square_band(
+            bm,
+            <span class="n">0.5</span> * (wall_z0 + wall_z1),
+            half - grip,
+            SHOE_T,
+            wall_z1 - wall_z0,
+            METAL_IDX,
+        )
         <span class="k">for</span> z <span class="k">in</span> BAND_ZS:
-            add_square_band(bm, z, half - <span class="n">0.002</span>, BAND_T, BAND_H, METAL_IDX)
-
-        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>):
-            <span class="c"># Eye on the -Y arm face; hitching ring threads it (YZ vs XZ).</span>
-            add_rim(
+            add_square_band(bm, z, half - grip, BAND_T, BAND_H, METAL_IDX)
+
+        arm_bottom = ARM_Z - ARM_ZTH * <span class="n">0.5</span>
+        eye_z = arm_bottom - EYE_MAJOR - EYE_MINOR - <span class="n">0.004</span>
+        <span class="c"># Shank stops in the top of the eye tube. Continuing it to the eye</span>
+        <span class="c"># center runs the pin through the hung ring.</span>
+        shank_bot = eye_z + EYE_MAJOR - <span class="n">0.002</span>
+        shank_top = arm_bottom + <span class="n">0.012</span>
+        shank_h = shank_top - shank_bot
+        ring_lift = <span class="n">0.024</span> <span class="k">if</span> clip_ring <span class="k">else</span> <span class="n">0.0</span>
+        <span class="k">for</span> sx <span class="k">in</span> (-EYE_X, EYE_X):
+            add_cyl(
+                bm,
+                (sx, <span class="n">0.0</span>, shank_bot + shank_h * <span class="n">0.5</span>),
+                EYE_MINOR * <span class="n">0.9</span>,
+                shank_h,
+                <span class="n">8</span>,
+                METAL_IDX,
+            )
+            add_torus(
                 bm,
-                (sx, arm_y_face + EYE_MINOR * <span class="n">0.25</span>, ARM_Z),
+                (sx, <span class="n">0.0</span>, eye_z),
                 EYE_MAJOR,
                 EYE_MINOR,
+                (<span class="n">1.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>),
                 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>,
+                n_major=<span class="n">16</span>,
+                n_minor=<span class="n">8</span>,
             )
-            add_rim(
+            add_torus(
                 bm,
-                (
-                    sx,
-                    arm_y_face - RING_MAJOR * <span class="n">0.55</span>,
-                    ARM_Z - RING_MAJOR * <span class="n">0.28</span>,
-                ),
+                (sx, <span class="n">0.0</span>, eye_z - RING_MAJOR + ring_lift),
                 RING_MAJOR,
                 RING_MINOR,
+                (<span class="n">0.0</span>, <span class="n">1.0</span>, <span class="n">0.0</span>),
                 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_major=<span class="n">24</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]
-        rcx = <span class="n">0.5</span> * (min(xs) + max(xs))
-        rcy = <span class="n">0.5</span> * (min(ys) + max(ys))
         zmin = min(zs)
         <span class="k">for</span> v <span class="k">in</span> bm.verts:
-            v.co.x -= rcx
-            v.co.y -= rcy
             v.co.z -= zmin
             <span class="k">if</span> v.co.z &lt; <span class="n">0.0</span>:
                 v.co.z = <span class="n">0.0</span>
@@ -796,10 +1097,7 @@ <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:
-            <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>
+            face.smooth = face.material_index == METAL_IDX
         <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>
@@ -816,7 +1114,6 @@ <h2>Source</h2>
     bpy.context.collection.objects.link(out)
     <span class="k">return</span> out
 
-
 <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>
@@ -968,9 +1265,23 @@ <h2>Source</h2>
     )
 
 
-<span class="k">def</span> check(skip_decimate, lift_z=<span class="k">False</span>):
+<span class="k">def</span> check(
+    skip_decimate,
+    lift_z=<span class="k">False</span>,
+    stray_vert=<span class="k">False</span>,
+    twin_sole=<span class="k">False</span>,
+    clip_ring=<span class="k">False</span>,
+    short_post=<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.008</span>, bevel_segments=<span class="n">2</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>,
+        short_post=short_post,
+        clip_ring=clip_ring,
+        twin_sole=twin_sole,
+    )
     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>,
@@ -980,13 +1291,22 @@ <h2>Source</h2>
         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>)
+    metal = principled(
+        <span class="s">&quot;HitchPostIron&quot;</span>,
+        (<span class="n">0.16</span>, <span class="n">0.155</span>, <span class="n">0.15</span>, <span class="n">1.0</span>),
+        <span class="n">1.0</span>,
+        <span class="n">0.48</span>,
+        noise_scale=<span class="n">16.0</span>,
+        wear=(<span class="n">0.09</span>, <span class="n">0.085</span>, <span class="n">0.08</span>, <span class="n">1.0</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> stray_vert:
+        add_stray_vert(low.data)
 
     <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>
@@ -1048,7 +1368,9 @@ <h2>Source</h2>
         <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)
+    zfight = zfight_pairs(low.data)
     gap = min_mat_distance(low.data, METAL_IDX, WOOD_IDX)
+    seat = seat_audit(low.data)
     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>
@@ -1056,9 +1378,19 @@ <h2>Source</h2>
     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>
+        <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"> </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">zfight=</span>{zfight}<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>)
+    print(
+        <span class="s">f&quot;</span><span class="s">measured seat post_zmin=</span>{seat[<span class="s">&#x27;post_zmin&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> post_xy=</span>{seat[<span class="s">&#x27;post_xy&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">arm_cos=</span>{seat[<span class="s">&#x27;arm_cos&#x27;</span>]:<span class="s">.6f</span>}<span class="s"> ring_err=</span>{seat[<span class="s">&#x27;ring_err&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">ring_wood=</span>{seat[<span class="s">&#x27;ring_wood&#x27;</span>]}<span class="s"> eye_wood=</span>{seat[<span class="s">&#x27;eye_wood&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">band_gap=</span>{seat[<span class="s">&#x27;band_gap&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> sole_shoe=</span>{seat[<span class="s">&#x27;sole_shoe&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">shank_ring=</span>{seat[<span class="s">&#x27;shank_ring&#x27;</span>]}<span class="s"> shank_eye=</span>{seat[<span class="s">&#x27;shank_eye&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">parts=</span>{seat[<span class="s">&#x27;post&#x27;</span>]}<span class="s">/</span>{seat[<span class="s">&#x27;arm&#x27;</span>]}<span class="s">/</span>{seat[<span class="s">&#x27;cap&#x27;</span>]}<span class="s">/</span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">soles=</span>{seat[<span class="s">&#x27;soles&#x27;</span>]}<span class="s">/rings=</span>{seat[<span class="s">&#x27;rings&#x27;</span>]}<span class="s">/eyes=</span>{seat[<span class="s">&#x27;eyes&#x27;</span>]}<span class="s">/bands=</span>{seat[<span class="s">&#x27;bands&#x27;</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(
@@ -1127,14 +1459,16 @@ <h2>Source</h2>
         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;zero_area&quot;</span>]
         <span class="k">or</span> hyg[<span class="s">&quot;doubles&quot;</span>]
         <span class="k">or</span> hyg[<span class="s">&quot;ngons&quot;</span>]
+        <span class="k">or</span> zfight
     ):
         <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="s">f&quot;</span><span class="s">doubles=</span>{hyg[<span class="s">&#x27;doubles&#x27;</span>]}<span class="s"> ngons=</span>{hyg[<span class="s">&#x27;ngons&#x27;</span>]}<span class="s"> zfight=</span>{zfight}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">&quot;(--stray-vert / --twin-sole are the designed fails)&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:
@@ -1148,6 +1482,39 @@ <h2>Source</h2>
             <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">if</span> (
+        seat[<span class="s">&quot;rings&quot;</span>] != <span class="n">2</span>
+        <span class="k">or</span> seat[<span class="s">&quot;eyes&quot;</span>] != <span class="n">2</span>
+        <span class="k">or</span> seat[<span class="s">&quot;bands&quot;</span>] &lt; <span class="n">3</span>
+        <span class="k">or</span> seat[<span class="s">&quot;soles&quot;</span>] &lt; <span class="n">1</span>
+        <span class="k">or</span> seat[<span class="s">&quot;ring_err&quot;</span>] &gt; RING_CENTER_TOL
+        <span class="k">or</span> seat[<span class="s">&quot;ring_wood&quot;</span>]
+        <span class="k">or</span> seat[<span class="s">&quot;eye_wood&quot;</span>]
+        <span class="k">or</span> seat[<span class="s">&quot;shanks&quot;</span>] != <span class="n">2</span>
+        <span class="k">or</span> seat[<span class="s">&quot;band_gap&quot;</span>] &gt; GAP_MAX
+        <span class="k">or</span> seat[<span class="s">&quot;sole_shoe&quot;</span>] &lt; <span class="n">1</span>
+        <span class="k">or</span> seat[<span class="s">&quot;shank_ring&quot;</span>]
+        <span class="k">or</span> seat[<span class="s">&quot;shank_eye&quot;</span>] &lt; <span class="n">1</span>
+    ):
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">hung ring / shoe seat ring_err=</span>{seat[<span class="s">&#x27;ring_err&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">f&quot;</span><span class="s">ring_wood=</span>{seat[<span class="s">&#x27;ring_wood&#x27;</span>]}<span class="s"> eye_wood=</span>{seat[<span class="s">&#x27;eye_wood&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">f&quot;</span><span class="s">band_gap=</span>{seat[<span class="s">&#x27;band_gap&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> sole_shoe=</span>{seat[<span class="s">&#x27;sole_shoe&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">f&quot;</span><span class="s">shank_ring=</span>{seat[<span class="s">&#x27;shank_ring&#x27;</span>]}<span class="s"> shank_eye=</span>{seat[<span class="s">&#x27;shank_eye&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">&quot;(--clip-ring is the designed fail)&quot;</span>,
+            <span class="n">18</span>,
+        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+    <span class="k">if</span> (
+        <span class="k">not</span> (POST_ZMIN_LO &lt; seat[<span class="s">&quot;post_zmin&quot;</span>] &lt; POST_ZMIN_HI)
+        <span class="k">or</span> seat[<span class="s">&quot;post_xy&quot;</span>] &gt; POST_XY_MAX
+        <span class="k">or</span> seat[<span class="s">&quot;arm_cos&quot;</span>] &lt; AXIS_COS_MIN
+    ):
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">post seat zmin=</span>{seat[<span class="s">&#x27;post_zmin&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> xy=</span>{seat[<span class="s">&#x27;post_xy&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">f&quot;</span><span class="s">arm_cos=</span>{seat[<span class="s">&#x27;arm_cos&#x27;</span>]:<span class="s">.6f</span>}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">&quot;(--short-post is the designed fail)&quot;</span>,
+            <span class="n">19</span>,
+        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
     <span class="k">return</span> <span class="n">0</span>, low, high, wood, tex, collider
 
 
@@ -1271,9 +1638,36 @@ <h2>Source</h2>
         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>,
     )
+    p.add_argument(
+        <span class="s">&quot;--stray-vert&quot;</span>,
+        action=<span class="s">&quot;store_true&quot;</span>,
+        help=<span class="s">&quot;falsification: one loose vertex so the hygiene budget fails&quot;</span>,
+    )
+    p.add_argument(
+        <span class="s">&quot;--twin-sole&quot;</span>,
+        action=<span class="s">&quot;store_true&quot;</span>,
+        help=<span class="s">&quot;falsification: duplicate the shoe plate so coplanar faces fail&quot;</span>,
+    )
+    p.add_argument(
+        <span class="s">&quot;--clip-ring&quot;</span>,
+        action=<span class="s">&quot;store_true&quot;</span>,
+        help=<span class="s">&quot;falsification: lift the rings off the eye centerline&quot;</span>,
+    )
+    p.add_argument(
+        <span class="s">&quot;--short-post&quot;</span>,
+        action=<span class="s">&quot;store_true&quot;</span>,
+        help=<span class="s">&quot;falsification: start the post above the shoe cup&quot;</span>,
+    )
     args = p.parse_args(argv)
 
-    code, low, _high, wood, tex, _col = check(args.skip_decimate, lift_z=args.lift_z)
+    code, low, _high, wood, tex, _col = check(
+        args.skip_decimate,
+        lift_z=args.lift_z,
+        stray_vert=args.stray_vert,
+        twin_sole=args.twin_sole,
+        clip_ring=args.clip_ring,
+        short_post=args.short_post,
+    )
     <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 9a6a8ed0..a0f8e450 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 (corner-aligned cap, stub-and-tenon arm, collar shoe, eye-threaded rings) through UVs, bake, LOD, collider, and Unity glTF…" loading="lazy" decoding="async" />
+          <img src="assets/hitching-post-hero.webp" alt="hitching-post — A procedural hitching post (eaved cap, one rail, cup shoe, rings hung through eyes) through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed…" 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 (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>
+          <p class="teaches">A procedural hitching post (eaved cap, one rail, cup shoe, rings hung through eyes) 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: 1680 tris, two materials with 114 wood and 742 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.500×0.149×1.246 m, zmin 0, hygiene and coplanar pairs 0, post seated at z 0.010, ring centerline error 0, LOD ratios in band, convex collider 80 tris, non-empty glTF. --skip-decimate exits 9; --stray-vert and --twin-sole exit 15; --lift-z exits 16; --clip-ring exits 18; --short-post exits 19.</p>
           <a class="card-link" href="hitching-post/">View example <span aria-hidden="true">&rarr;</span></a>
         </div>
       </article>
@@ -1151,12 +1151,12 @@ <h2><a href="iron-cauldron/">iron-cauldron</a></h2>
       </article>
       <article class="card" data-tags="mesh export showcase">
         <a class="card-media" href="wooden-ladder/" aria-label="wooden-ladder example detail page">
-          <img src="assets/wooden-ladder-hero.webp" alt="wooden-ladder — A procedural timber ladder with raked stiles, six dowel rungs tenoned into the stiles, and iron shoes and top caps through UVs, bake, LOD, collider, and Unity…" loading="lazy" decoding="async" />
+          <img src="assets/wooden-ladder-hero.webp" alt="wooden-ladder — A procedural timber ladder with raked tapered stiles, six turned rungs, ferrule caps, and level shoe plates through UVs, bake, LOD, collider, and Unity glTF…" loading="lazy" decoding="async" />
         </a>
         <div class="card-body">
           <h2><a href="wooden-ladder/">wooden-ladder</a></h2>
-          <p class="teaches">A procedural timber ladder with raked stiles, six dowel rungs tenoned into the stiles, and iron shoes and top caps 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: 936 tris, two materials with 324 wood and 216 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.472×0.365×1.460 m, grounded at zmin 0, mesh hygiene all zero, 12 shells with every rung clearing the stile chamfer by 3.61 mm, convex collider 24 tris, non-empty glTF. Four falsifiers exit 9, 15, 16, and 17 on the LOD, hygiene, grounded, and joint-fit budgets.</p>
+          <p class="teaches">A procedural timber ladder with raked tapered stiles, six turned rungs, ferrule caps, and level shoe plates 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: 2536 tris, two materials with 612 wood and 736 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.490×0.376×1.487 m, zmin 0, hygiene and coplanar pairs 0, tenon clearance 8 mm, shoe bite 20 mm, LOD ratios in band, convex collider 24 tris, non-empty glTF. --skip-decimate exits 9; --stray-vert and --twin-sole exit 15; --lift-z exits 16; --fat-rungs exits 17; --short-stile exits 18.</p>
           <a class="card-link" href="wooden-ladder/">View example <span aria-hidden="true">&rarr;</span></a>
         </div>
       </article>
diff --git a/docs/gallery/wooden-ladder/index.html b/docs/gallery/wooden-ladder/index.html
index 6383b835..bc93df0d 100644
--- a/docs/gallery/wooden-ladder/index.html
+++ b/docs/gallery/wooden-ladder/index.html
@@ -4,18 +4,18 @@
   <meta charset="utf-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1" />
   <title>wooden-ladder — Examples — Blender Developer Tools</title>
-  <meta name="description" content="A procedural timber ladder with raked stiles, six dowel rungs tenoned into the stiles, and iron shoes and top caps through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
+  <meta name="description" content="A procedural timber ladder with raked tapered stiles, six turned rungs, ferrule caps, and level shoe plates 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/wooden-ladder/" />
   <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="wooden-ladder — Examples — Blender Developer Tools" />
-  <meta property="og:description" content="A procedural timber ladder with raked stiles, six dowel rungs tenoned into the stiles, and iron shoes and top caps through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
+  <meta property="og:description" content="A procedural timber ladder with raked tapered stiles, six turned rungs, ferrule caps, and level shoe plates 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/wooden-ladder/" />
   <meta property="og:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/wooden-ladder-hero.webp" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="wooden-ladder — Examples — Blender Developer Tools" />
-  <meta name="twitter:description" content="A procedural timber ladder with raked stiles, six dowel rungs tenoned into the stiles, and iron shoes and top caps through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
+  <meta name="twitter:description" content="A procedural timber ladder with raked tapered stiles, six turned rungs, ferrule caps, and level shoe plates 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/wooden-ladder-hero.webp" />
   <style>
     /* fonts are deployed by the landing build (docs/fonts/) */
@@ -246,43 +246,45 @@
   </div>
   <header class="hero">
     <h1>wooden-ladder</h1>
-    <p>A procedural timber ladder with raked stiles, six dowel rungs tenoned into the stiles, and iron shoes and top caps through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.</p>
+    <p>A procedural timber ladder with raked tapered stiles, six turned rungs, ferrule caps, and level shoe plates 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 wooden-ladder render">
       <img src="../assets/wooden-ladder-hero.webp" alt="wooden-ladder 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: 936 tris, two materials with 324 wood and 216 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.472×0.365×1.460 m, grounded at zmin 0, mesh hygiene all zero, 12 shells with every rung clearing the stile chamfer by 3.61 mm, convex collider 24 tris, non-empty glTF. Four falsifiers exit 9, 15, 16, and 17 on the LOD, hygiene, grounded, and joint-fit budgets.</div>
+    <div class="callout"><span class="tag">witnesses</span> Recomputed: 2536 tris, two materials with 612 wood and 736 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.490×0.376×1.487 m, zmin 0, hygiene and coplanar pairs 0, tenon clearance 8 mm, shoe bite 20 mm, LOD ratios in band, convex collider 24 tris, non-empty glTF. --skip-decimate exits 9; --stray-vert and --twin-sole exit 15; --lift-z exits 16; --fat-rungs exits 17; --short-stile exits 18.</div>
     <div class="runline">
       <pre id="runCmd">blender --background --python showcase/wooden-ladder/wooden_ladder.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 ladder (raked stiles, six 26 mm dowel rungs tenoned into the stiles, iron shoes and top caps) 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 ladder: two stiles tapered from 64 mm to 50 mm, raked 12°, six turned rungs (22 mm tenon, barrel thicker only in the clear span), iron ferrules at the top, and level shoe plates under sleeves that follow the rake. 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>Intended size: stile length 1.50 m, overall about 0.49 × 0.38 × 1.49 m. A household ladder, not a 3 m orchard ladder.</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). Coplanar-pair counting matches <code>showcase/signpost</code>.</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 | 900–975 | 936 / 936 / 936 | | LOD1 ratio | 0.32–0.62 of base | 0.5000 / 0.5000 / 0.5000 | | LOD2 ratio | 0.10–0.35 of base | 0.2179 / 0.2179 / 0.2179 | | Materials | exactly 2 distinct, ≥280 wood, ≥180 metal | 2 slots, 324 wood, 216 metal | | UVs | in <code>0..1</code>, AABB overlap ≤ 1e-5 | in range, overlap 0 | | Outer AABB | (0.472, 0.365, 1.460) m ± 0.01 | (0.4720, 0.3649, 1.4597) | | Grounded | <code>abs(zmin)</code> ≤ 1e-4 | 0.0000 | | Mesh hygiene | non-manifold, loose v/e, doubles at 1e-5, zero-area, n-gons all 0 | all 0 | | Parts | exactly 12 shells (2 stiles, 6 rungs, 2 caps, 2 shoes) | 12 (2 / 6) | | Rung depth clearance | ≥ 0.003 m inside the stile faces | 0.00361 | | Tenon engagement | ≥ 0.006 m past the stile inner face | 0.01200 | | Tenon breakout margin | ≥ 0.005 m short of the stile outer face | 0.04600 | | Collider tris | ≤ 120 | 24 | | Export | written, size &gt; 0 | 75140 / 75140 / 75128 bytes |</p>
-<p>Base triangles fell from <strong>2184 to 936</strong> in the quality pass: four iron fittings per stile collapsed to one shoe and one top cap, and the redundant top block came out. No hidden-face removal was involved.</p>
-<p>The rung rims are capped and buried in the stile rather than left open. That costs 144 tris nobody sees, but an open rim is a non-manifold boundary and the hygiene budget forbids it.</p>
-<p>The joint budgets are measured per rung against each stile, from vertex positions in the un-raked construction frame, and the reported value is the worst case over all twelve rung ends. <code>clearance</code> is how far the widest dowel stays inside the stile&#x27;s front and back faces; it must exceed the 2.5 mm chamfer or the dowel erupts through it as a spike.</p>
-<p>DECIMATE COLLAPSE triangle counts are <strong>not</strong> identical across series — the gate is a ratio band, not an exact count. On this mesh the three binaries agreed on LOD ratios. Bake pixels are stochastic; the gate is <code>has_data</code> plus operator <code>FINISHED</code>, not byte-identity. Construction uses no RNG. Export byte counts differ by 16 B on 5.2.1 (glTF serializer), not a gated axis.</p>
-<p>Each falsifier violates exactly one named budget, and each was proven to fire on all three binaries:</p>
-<p>| Falsifier | Budget violated | Exit | Measured failure | | --- | --- | --- | --- | | <code>--skip-decimate</code> | LOD1 ratio band | 9 | ratio 1.0000 | | <code>--stray-vert</code> | Mesh hygiene, loose verts | 15 | <code>loose_v=1</code> | | <code>--lift-z</code> | Grounded zmin | 16 | zmin 0.050000 | | <code>--fat-rungs</code> | Rung depth clearance | 17 | clearance −0.00051 |</p>
-<p><code>--fat-rungs</code> widens the dowels to the full 34 mm stile depth, which is the proportion this piece shipped with before the quality pass.</p>
+<p>| Axis | Declared | Measured (4.5.11 / 5.1.2 / 5.2.1) | | --- | --- | --- | | Base triangles | 1800–2800 | 2536 / 2536 / 2536 | | LOD1 ratio | 0.32–0.62 of base | 0.5000 / 0.5000 / 0.5000 | | LOD2 ratio | 0.10–0.35 of base | 0.2192 / 0.2192 / 0.2192 | | Materials | exactly 2 distinct, ≥280 wood, ≥180 metal | 2 slots, 612 wood, 736 metal | | UVs | in <code>0..1</code>, AABB overlap ≤ 1e-5 | in range, overlap 0 | | Outer AABB | (0.490, 0.376, 1.487) m ± 0.01 | (0.4897, 0.3760, 1.4870) | | Grounded | <code>abs(zmin)</code> ≤ 1e-4, each sole at 0, rail end ≥ 0.012 m | zmin 0, sole 0, rail 0.02037 | | Mesh hygiene | non-manifold, loose v/e, doubles at 1e-5, zero-area, n-gons, coplanar pairs all 0 | all 0 | | Parts | 16 shells (2 stiles, 6 rungs, 2 sleeves, 2 cap sleeves, 2 plates, 2 soles) | 16 (2 / 6 / 2 / 2) | | Rung depth clearance | ≥ 0.003 m inside the stile faces | 0.00800 | | Tenon engagement | ≥ 0.008 m past the stile inner face | 0.01399 | | Tenon breakout margin | ≥ 0.008 m short of the stile outer face | 0.03780 | | Shoe bite / cover | bite ≥ 0.010 m, cover ≥ 0.016 m | 0.02000 / 0.03800 | | Collider tris | ≤ 180 | 24 | | Export | written, size &gt; 0 | 187528 / 187528 / 187504 bytes |</p>
+<p>Base triangles rose from <strong>936 to 2536</strong>. The previous mesh was two boxes, six cloned dowels, and four chrome cubes. Turned rungs (tenon and barrel in one shell) plus ferrule collars and chamfered soles added the triangles. Nothing was removed as a hidden face.</p>
+<p>The joint budgets are measured per rung against each stile, from vertex positions in the un-raked construction frame, and the reported value is the worst case. Clearance is the tenon, not the barrel: the barrel is thicker only between the stiles.</p>
+<p>DECIMATE COLLAPSE triangle counts are <strong>not</strong> identical across series — the gate is a ratio band, not an exact count. On this mesh the three binaries agreed. 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 24 B on 5.2.1 (glTF serializer), not a gated axis. Euler is 24 (multi-body) and is not gated to 2.</p>
+<p>Each falsifier violates exactly one named budget. Proven on Blender 4.5.11 LTS, 5.1.2, and 5.2.1 LTS (the binaries&#x27; own <code>--version</code>):</p>
+<p>| Falsifier | Budget violated | Exit | Measured failure | | --- | --- | --- | --- | | <code>--skip-decimate</code> | LOD1 ratio band | 9 | ratio 1.0000 | | <code>--stray-vert</code> | Mesh hygiene, loose verts | 15 | <code>loose_v=1</code> | | <code>--twin-sole</code> | Coplanar face pairs | 15 | <code>zfight=6</code> | | <code>--lift-z</code> | Grounded zmin | 16 | zmin 0.050000 | | <code>--fat-rungs</code> | Rung depth clearance | 17 | clearance 0 | | <code>--short-stile</code> | Shoe bite / cover | 18 | bite 0.070, cover −0.012 |</p>
+<p>Default exit is 0 on all three.</p>
 <h2>Run</h2>
 <pre><code>blender --background --python wooden_ladder.py --
 blender --background --python wooden_ladder.py -- --skip-decimate
 blender --background --python wooden_ladder.py -- --stray-vert
+blender --background --python wooden_ladder.py -- --twin-sole
 blender --background --python wooden_ladder.py -- --lift-z
 blender --background --python wooden_ladder.py -- --fat-rungs
-blender --background --python wooden_ladder.py -- --output ladder.png</code></pre>
+blender --background --python wooden_ladder.py -- --short-stile
+blender --background --python wooden_ladder.py -- --output preview.webp --engine cycles</code></pre>
 <p>Smoke passes no flags: no <code>--output</code>, no falsifier.</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 | | 15 | Mesh hygiene (<code>--stray-vert</code> lands here) | | 16 | World AABB min Z off the floor (<code>--lift-z</code> lands here) | | 17 | Part count or rung-to-stile joint fit (<code>--fat-rungs</code> lands here) |</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 | Mesh hygiene, including coplanar pairs (<code>--stray-vert</code>, <code>--twin-sole</code>) | | 16 | Grounded zmin, or a rail end sitting in the tread (<code>--lift-z</code>) | | 17 | Part count or rung-to-stile joint fit (<code>--fat-rungs</code>) | | 18 | Shoe bite / cover (<code>--short-stile</code>) |</p>
     </section>
     <section class="detail-section src">
       <h2>Source</h2>
@@ -336,42 +338,50 @@ <h2>Source</h2>
 sys.dont_write_bytecode = <span class="k">True</span>
 <span class="k">import</span> gallery_framing  <span class="c"># noqa: E402</span>
 
-STILE_H = <span class="n">1.48</span>
-STILE_W = <span class="n">0.058</span>
-STILE_D = <span class="n">0.034</span>
-SPAN = <span class="n">0.34</span>
+STILE_H = <span class="n">1.50</span>
+STILE_W_BOT = <span class="n">0.064</span>
+STILE_W_TOP = <span class="n">0.050</span>
+STILE_D = <span class="n">0.038</span>
+CENTER = <span class="n">0.198</span>
 N_RUNGS = <span class="n">6</span>
-<span class="c"># A 26 mm dowel in a 34 mm stile. Sized so the widest rung still clears the</span>
-<span class="c"># stile&#x27;s 2.5 mm chamfer by more than a millimetre; at 17 mm the dowel was as</span>
-<span class="c"># deep as the stile and broke through the front and back chamfers as a spike.</span>
-RUNG_R = <span class="n">0.013</span>
+<span class="c"># Tenon stays inside the chamfer. The visible barrel is wider and stops</span>
+<span class="c"># outside the stile, so the two radii are different stations.</span>
+RUNG_R = <span class="n">0.011</span>
+BARREL_RATIO = <span class="n">1.34</span>
 RUNG_SEGS = <span class="n">12</span>
-RUNG_TENON = <span class="n">0.012</span>
-RUNG_RADIUS_SCALE = (<span class="n">0.98</span>, <span class="n">1.02</span>, <span class="n">0.99</span>, <span class="n">1.03</span>, <span class="n">0.97</span>, <span class="n">1.01</span>)
-RUNG_Z_OFFSETS = (<span class="n">0.0</span>, <span class="n">0.0015</span>, -<span class="n">0.0010</span>, <span class="n">0.0010</span>, -<span class="n">0.0015</span>, <span class="n">0.0</span>)
-TOP_CAP_H = <span class="n">0.025</span>
-SHOE_H = <span class="n">0.065</span>
-SHOE_W = <span class="n">0.074</span>
-SHOE_D = <span class="n">0.070</span>
+RUNG_TENON = <span class="n">0.014</span>
+RUNG_BARREL_SCALE = (<span class="n">1.00</span>, <span class="n">1.16</span>, <span class="n">0.86</span>, <span class="n">1.22</span>, <span class="n">0.82</span>, <span class="n">1.10</span>)
+RUNG_Z_OFFSETS = (<span class="n">0.0</span>, <span class="n">0.016</span>, -<span class="n">0.012</span>, <span class="n">0.014</span>, -<span class="n">0.018</span>, <span class="n">0.008</span>)
+BAND_Z0 = <span class="n">0.0</span>
+BAND_H = <span class="n">0.058</span>
+BAND_T = <span class="n">0.007</span>
+RAIL_Z0 = <span class="n">0.020</span>
+CAP_DROP = <span class="n">0.010</span>
+CAP_RISE = <span class="n">0.016</span>
+PLATE_H = <span class="n">0.006</span>
+SOLE_H = <span class="n">0.032</span>
+SOLE_PAD = <span class="n">0.008</span>
 RAKE = math.radians(<span class="n">12.0</span>)
 BBOX_TOL = <span class="n">0.01</span>
-<span class="c"># 2 stiles + 6 rungs + 2 top caps + 2 shoes, each a closed shell.</span>
-PART_COUNT = <span class="n">12</span>
-<span class="c"># Measured joint contract. Clearance exceeds the 2.5 mm chamfer so the dowel</span>
-<span class="c"># stays on the stile&#x27;s flat face; engagement keeps the tenon seated; breakout</span>
-<span class="c"># keeps it from reaching the outer face.</span>
+<span class="c"># 2 stiles + 6 rungs + 2 shoe sleeves + 2 cap sleeves + 2 cap plates + 2 soles.</span>
+PART_COUNT = <span class="n">16</span>
 RUNG_DEPTH_CLEARANCE = <span class="n">0.003</span>
-TENON_ENGAGE_MIN = <span class="n">0.006</span>
-TENON_BREAKOUT_MIN = <span class="n">0.005</span>
+TENON_ENGAGE_MIN = <span class="n">0.008</span>
+TENON_BREAKOUT_MIN = <span class="n">0.008</span>
+SHOE_BITE_MIN = <span class="n">0.010</span>
+SHOE_COVER_MIN = <span class="n">0.016</span>
+RAIL_ZMIN_MIN = <span class="n">0.012</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>
+ZFIGHT_EPS = <span class="n">0.002</span>
+ZFIGHT_COS = <span class="n">0.98</span>
 LIFT_Z = <span class="n">0.05</span>
 <span class="c"># Fitted after locking geometry. Recomputed from bound_box.</span>
-OUTER_SIZE = (<span class="n">0.472</span>, <span class="n">0.365</span>, <span class="n">1.460</span>)
+OUTER_SIZE = (<span class="n">0.490</span>, <span class="n">0.376</span>, <span class="n">1.487</span>)
 
-BASE_TRIS_MIN = <span class="n">900</span>
-BASE_TRIS_MAX = <span class="n">975</span>
+BASE_TRIS_MIN = <span class="n">1800</span>
+BASE_TRIS_MAX = <span class="n">2800</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>
@@ -381,7 +391,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">180</span>
 BAKE_RES = <span class="n">256</span>
 CAGE_EXTRUSION = <span class="n">0.06</span>
 <span class="c"># The caps and shoes carry far more chamfer than body faces, so a floor above</span>
@@ -459,6 +469,128 @@ <h2>Source</h2>
     <span class="k">return</span> add_cone(bm, loc, radius, radius, depth, segments, mat_idx, euler=euler)
 
 
+<span class="k">def</span> half_w(z):
+    t = min(<span class="n">1.0</span>, max(<span class="n">0.0</span>, z / STILE_H))
+    <span class="k">return</span> <span class="n">0.5</span> * (STILE_W_BOT + (STILE_W_TOP - STILE_W_BOT) * t)
+
+
+<span class="k">def</span> inner_x(z, sign):
+    x = sign * CENTER
+    hw = half_w(z)
+    <span class="k">return</span> x + hw <span class="k">if</span> sign &lt; <span class="n">0.0</span> <span class="k">else</span> x - hw
+
+
+<span class="k">def</span> add_ruled_box(bm, x, z0, z1, hw0, hw1, hd, mat_idx):
+    <span class="s">&quot;&quot;&quot;Tapered box. Width is the local X half-extent at each end; depth is constant.&quot;&quot;&quot;</span>
+
+    <span class="k">def</span> ring(z, hw):
+        <span class="k">return</span> [
+            bm.verts.new((x - hw, -hd, z)),
+            bm.verts.new((x + hw, -hd, z)),
+            bm.verts.new((x + hw, hd, z)),
+            bm.verts.new((x - hw, hd, z)),
+        ]
+
+    bottom = ring(z0, hw0)
+    top = ring(z1, hw1)
+
+    <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> i <span class="k">in</span> range(<span class="n">4</span>):
+        j = (i + <span class="n">1</span>) % <span class="n">4</span>
+        quad(bottom[i], bottom[j], top[j], top[i])
+    quad(bottom[<span class="n">3</span>], bottom[<span class="n">2</span>], bottom[<span class="n">1</span>], bottom[<span class="n">0</span>])
+    quad(top[<span class="n">0</span>], top[<span class="n">1</span>], top[<span class="n">2</span>], top[<span class="n">3</span>])
+    <span class="k">return</span> bottom + top
+
+
+<span class="k">def</span> add_rect_band(bm, zc, cx, hx, hy, tx, ty, h, mat_idx):
+    <span class="s">&quot;&quot;&quot;Closed rectangular collar, constant section, axis along local Z.&quot;&quot;&quot;</span>
+    z0 = zc - h * <span class="n">0.5</span>
+    z1 = zc + h * <span class="n">0.5</span>
+    inner = (
+        (cx + hx, hy),
+        (cx - hx, hy),
+        (cx - hx, -hy),
+        (cx + hx, -hy),
+    )
+    outer = (
+        (cx + hx + tx, hy + ty),
+        (cx - hx - tx, hy + ty),
+        (cx - hx - tx, -(hy + ty)),
+        (cx + hx + tx, -(hy + ty)),
+    )
+
+    <span class="k">def</span> ring(z, pts):
+        <span class="k">return</span> [bm.verts.new((p[<span class="n">0</span>], p[<span class="n">1</span>], z)) <span class="k">for</span> p <span class="k">in</span> pts]
+
+    i0, o0 = ring(z0, inner), ring(z0, outer)
+    i1, o1 = ring(z1, inner), 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> add_turned_rung(bm, z, x_left, x_right, tenon, r_tenon, r_barrel, segs, mat_idx):
+    <span class="s">&quot;&quot;&quot;One shell: thin tenon inside each stile, thicker barrel only in the clear span.&quot;&quot;&quot;</span>
+    xs = (
+        x_left - tenon,
+        x_left - <span class="n">0.0015</span>,
+        x_left + <span class="n">0.004</span>,
+        x_right - <span class="n">0.004</span>,
+        x_right + <span class="n">0.0015</span>,
+        x_right + tenon,
+    )
+    rs = (r_tenon, r_tenon, r_barrel, r_barrel, r_tenon, r_tenon)
+    rings = []
+    <span class="k">for</span> x, radius <span class="k">in</span> zip(xs, rs):
+        ring = []
+        <span class="k">for</span> i <span class="k">in</span> range(segs):
+            ang = i * (<span class="n">2.0</span> * math.pi / segs)
+            ring.append(bm.verts.new((
+                x,
+                radius * math.cos(ang),
+                z + radius * math.sin(ang),
+            )))
+        rings.append(ring)
+    bm.verts.ensure_lookup_table()
+
+    <span class="k">def</span> face(verts):
+        poly = bm.faces.new(verts)
+        poly.material_index = mat_idx
+        <span class="k">return</span> poly
+
+    <span class="k">for</span> i <span class="k">in</span> range(len(rings) - <span class="n">1</span>):
+        <span class="k">for</span> j <span class="k">in</span> range(segs):
+            j2 = (j + <span class="n">1</span>) % segs
+            face((rings[i][j], rings[i][j2], rings[i + <span class="n">1</span>][j2], rings[i + <span class="n">1</span>][j]))
+    <span class="k">for</span> ring, x, radius, outward <span class="k">in</span> (
+        (rings[<span class="n">0</span>], xs[<span class="n">0</span>], rs[<span class="n">0</span>], -<span class="n">1.0</span>),
+        (rings[-<span class="n">1</span>], xs[-<span class="n">1</span>], rs[-<span class="n">1</span>], <span class="n">1.0</span>),
+    ):
+        cap = bm.verts.new((x, <span class="n">0.0</span>, z))
+        <span class="k">for</span> j <span class="k">in</span> range(segs):
+            j2 = (j + <span class="n">1</span>) % segs
+            <span class="k">if</span> outward &lt; <span class="n">0.0</span>:
+                face((cap, ring[j2], ring[j]))
+            <span class="k">else</span>:
+                face((cap, ring[j], ring[j2]))
+    <span class="k">return</span> [v <span class="k">for</span> ring <span class="k">in</span> rings <span class="k">for</span> v <span class="k">in</span> ring]
+
+
 <span class="k">def</span> 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)
@@ -502,39 +634,55 @@ <h2>Source</h2>
             )
 
 
-<span class="k">def</span> build_ladder_mesh(name, bevel_offset, bevel_segments, rung_radius=RUNG_R):
+<span class="k">def</span> build_ladder_mesh(
+    name,
+    bevel_offset,
+    bevel_segments,
+    rung_radius=RUNG_R,
+    short_stile=<span class="k">False</span>,
+    twin_sole=<span class="k">False</span>,
+):
+    <span class="s">&quot;&quot;&quot;Raked tapered rails, turned rungs, sleeve shoes with level soles.
+
+    The sleeve is built in the rail frame so it follows the rake. The sole
+    is a separate world-level plate the sleeve bites into. The rail ends
+    inside the sleeve, above the sole.
+    &quot;&quot;&quot;</span>
     bm = bmesh.new()
-    stile_verts = []
     metal_faces = set()
-    metal_verts = []
     <span class="k">try</span>:
-        half = SPAN / <span class="n">2.0</span> + STILE_W / <span class="n">2.0</span>
+        rail_z0 = (BAND_Z0 + BAND_H + <span class="n">0.012</span>) <span class="k">if</span> short_stile <span class="k">else</span> RAIL_Z0
+        rail_z1 = STILE_H - CAP_DROP
+        stile_verts = []
         <span class="k">for</span> sign <span class="k">in</span> (-<span class="n">1.0</span>, <span class="n">1.0</span>):
             stile_verts.extend(
-                add_box(
+                add_ruled_box(
                     bm,
-                    (sign * half, <span class="n">0.0</span>, STILE_H / <span class="n">2.0</span>),
-                    (STILE_W, STILE_D, STILE_H),
+                    sign * CENTER,
+                    rail_z0,
+                    rail_z1,
+                    half_w(rail_z0),
+                    half_w(rail_z1),
+                    STILE_D * <span class="n">0.5</span>,
                     WOOD_IDX,
                 )
             )
 
-        z0 = <span class="n">0.16</span>
-        z1 = STILE_H - <span class="n">0.14</span>
+        z_lo = <span class="n">0.22</span>
+        z_hi = STILE_H - <span class="n">0.20</span>
         <span class="k">for</span> i <span class="k">in</span> range(N_RUNGS):
             t = i / (N_RUNGS - <span class="n">1</span>)
-            z = z0 + t * (z1 - z0) + RUNG_Z_OFFSETS[i]
-            <span class="c"># Tenons stop inside the stile, so the rung rims never reach the</span>
-            <span class="c"># chamfered outer face. Rungs stay unbeveled: they are already</span>
-            <span class="c"># round, and beveling a cap rim spikes through that chamfer.</span>
-            add_cylinder(
+            z = z_lo + t * (z_hi - z_lo) + RUNG_Z_OFFSETS[i]
+            add_turned_rung(
                 bm,
-                (<span class="n">0.0</span>, <span class="n">0.0</span>, z),
-                rung_radius * RUNG_RADIUS_SCALE[i],
-                SPAN + <span class="n">2.0</span> * RUNG_TENON,
+                z,
+                inner_x(z, -<span class="n">1.0</span>),
+                inner_x(z, <span class="n">1.0</span>),
+                RUNG_TENON,
+                rung_radius,
+                rung_radius * BARREL_RATIO * RUNG_BARREL_SCALE[i],
                 RUNG_SEGS,
                 WOOD_IDX,
-                euler=(<span class="n">0.0</span>, math.pi / <span class="n">2.0</span>, <span class="n">0.0</span>),
             )
 
         <span class="k">if</span> bevel_offset &gt; <span class="n">0.0</span>:
@@ -558,25 +706,85 @@ <h2>Source</h2>
                 )
 
         before = set(bm.faces)
+        metal_verts = []
+        hd = STILE_D * <span class="n">0.5</span>
         <span class="k">for</span> sign <span class="k">in</span> (-<span class="n">1.0</span>, <span class="n">1.0</span>):
-            hx = sign * half
+            x = sign * CENTER
+            shoe_z = BAND_Z0 + BAND_H * <span class="n">0.5</span>
+            grip = <span class="n">0.0015</span> + bevel_offset
+            metal_verts.extend(
+                add_rect_band(
+                    bm,
+                    shoe_z,
+                    x,
+                    half_w(shoe_z) - grip,
+                    hd - grip,
+                    BAND_T,
+                    BAND_T,
+                    BAND_H,
+                    METAL_IDX,
+                )
+            )
+            cap_h = CAP_RISE + <span class="n">0.006</span>
+            cap_z = rail_z1 + (CAP_RISE - <span class="n">0.006</span>) * <span class="n">0.5</span>
+            chw = half_w(rail_z1)
+            metal_verts.extend(
+                add_rect_band(
+                    bm,
+                    cap_z,
+                    x,
+                    chw - grip,
+                    hd - grip,
+                    BAND_T,
+                    BAND_T,
+                    cap_h,
+                    METAL_IDX,
+                )
+            )
+            <span class="c"># Plate overlaps the sleeve top so the two faces are not coplanar.</span>
+            plate_z = rail_z1 + CAP_RISE - <span class="n">0.002</span> + PLATE_H * <span class="n">0.5</span>
             metal_verts.extend(
                 add_box(
                     bm,
-                    (hx, <span class="n">0.0</span>, STILE_H - TOP_CAP_H * <span class="n">0.30</span>),
-                    (STILE_W + <span class="n">0.010</span>, STILE_D + <span class="n">0.010</span>, TOP_CAP_H),
+                    (x, <span class="n">0.0</span>, plate_z),
+                    (
+                        (chw + BAND_T) * <span class="n">2.0</span> + <span class="n">0.006</span>,
+                        (hd + BAND_T) * <span class="n">2.0</span> + <span class="n">0.006</span>,
+                        PLATE_H,
+                    ),
                     METAL_IDX,
                 )
             )
         metal_faces.update(set(bm.faces) - before)
 
+        <span class="k">if</span> bevel_offset &gt; <span class="n">0.0</span> <span class="k">and</span> metal_verts:
+            metal_edges = list(
+                {
+                    edge
+                    <span class="k">for</span> vertex <span class="k">in</span> metal_verts
+                    <span class="k">for</span> edge <span class="k">in</span> vertex.link_edges
+                    <span class="k">if</span> vertex.is_valid
+                }
+            )
+            <span class="k">if</span> metal_edges:
+                bevelled = bmesh.ops.bevel(
+                    bm,
+                    geom=metal_edges,
+                    offset=min(bevel_offset, <span class="n">0.0016</span>),
+                    segments=bevel_segments,
+                    profile=<span class="n">0.5</span>,
+                    affect=<span class="s">&quot;EDGES&quot;</span>,
+                    clamp_overlap=<span class="k">True</span>,
+                )
+                metal_faces.update(bevelled.get(<span class="s">&quot;faces&quot;</span>) <span class="k">or</span> [])
+
         rake = Euler((RAKE, <span class="n">0.0</span>, <span class="n">0.0</span>)).to_matrix()
         <span class="k">for</span> v <span class="k">in</span> bm.verts:
             v.co = rake @ v.co
         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]
         ys = [v.co.y <span class="k">for</span> v <span class="k">in</span> bm.verts]
+        zmin = min(zs)
         cx = <span class="n">0.5</span> * (min(xs) + max(xs))
         cy = <span class="n">0.5</span> * (min(ys) + max(ys))
         <span class="k">for</span> v <span class="k">in</span> bm.verts:
@@ -584,51 +792,60 @@ <h2>Source</h2>
             v.co.y -= cy
             v.co.z -= zmin
 
+        <span class="k">def</span> world_of(local):
+            q = rake @ Vector(local)
+            q.x -= cx
+            q.y -= cy
+            q.z -= zmin
+            <span class="k">return</span> q
+
         before = set(bm.faces)
+        sole_centers = []
+        sole_verts = []
         <span class="k">for</span> sign <span class="k">in</span> (-<span class="n">1.0</span>, <span class="n">1.0</span>):
-            bottom = rake @ Vector((sign * half, <span class="n">0.0</span>, <span class="n">0.0</span>))
-            bottom.x -= cx
-            bottom.y -= cy
-            bottom.z -= zmin
-            metal_verts.extend(
+            x = sign * CENTER
+            shoe_z = BAND_Z0 + BAND_H * <span class="n">0.5</span>
+            sole_w = (half_w(shoe_z) + BAND_T + SOLE_PAD) * <span class="n">2.0</span>
+            sole_d = (hd + BAND_T + SOLE_PAD) * <span class="n">2.0</span>
+            anchor = world_of((x, <span class="n">0.0</span>, <span class="n">0.0</span>))
+            sole_centers.append((anchor.x, anchor.y, sole_w, sole_d))
+            sole_verts.extend(
                 add_box(
                     bm,
-                    (bottom.x, bottom.y, SHOE_H / <span class="n">2.0</span>),
-                    (SHOE_W, SHOE_D, SHOE_H),
+                    (anchor.x, anchor.y, SOLE_H * <span class="n">0.5</span>),
+                    (sole_w, sole_d, SOLE_H),
                     METAL_IDX,
                 )
             )
-        metal_faces.update(set(bm.faces) - before)
-
-        <span class="k">if</span> bevel_offset &gt; <span class="n">0.0</span>:
-            metal_edges = list(
+        <span class="k">if</span> bevel_offset &gt; <span class="n">0.0</span> <span class="k">and</span> sole_verts:
+            sole_edges = list(
                 {
                     edge
-                    <span class="k">for</span> vertex <span class="k">in</span> metal_verts
+                    <span class="k">for</span> vertex <span class="k">in</span> sole_verts
                     <span class="k">for</span> edge <span class="k">in</span> vertex.link_edges
                     <span class="k">if</span> vertex.is_valid
                 }
             )
-            <span class="k">if</span> metal_edges:
-                <span class="c"># Bevel does not inherit material_index onto the faces it</span>
-                <span class="c"># creates, so claim them from the op&#x27;s own return rather than</span>
-                <span class="c"># from a pre-bevel face snapshot. Without this every chamfer</span>
-                <span class="c"># on a cap or shoe falls back to slot 0 and renders as wood.</span>
+            <span class="k">if</span> sole_edges:
                 bevelled = bmesh.ops.bevel(
                     bm,
-                    geom=metal_edges,
-                    offset=min(bevel_offset, <span class="n">0.002</span>),
-                    segments=bevel_segments,
+                    geom=sole_edges,
+                    offset=min(bevel_offset, <span class="n">0.0014</span>),
+                    segments=<span class="n">1</span>,
                     profile=<span class="n">0.5</span>,
                     affect=<span class="s">&quot;EDGES&quot;</span>,
                     clamp_overlap=<span class="k">True</span>,
                 )
                 metal_faces.update(bevelled.get(<span class="s">&quot;faces&quot;</span>) <span class="k">or</span> [])
-
-        ys = [v.co.y <span class="k">for</span> v <span class="k">in</span> bm.verts]
-        final_cy = <span class="n">0.5</span> * (min(ys) + max(ys))
-        <span class="k">for</span> v <span class="k">in</span> bm.verts:
-            v.co.y -= final_cy
+        <span class="k">if</span> twin_sole <span class="k">and</span> sole_centers:
+            sx, sy, sw, sd = sole_centers[<span class="n">0</span>]
+            add_box(
+                bm,
+                (sx + <span class="n">0.0012</span>, sy + <span class="n">0.0012</span>, SOLE_H * <span class="n">0.5</span>),
+                (sw, sd, SOLE_H),
+                METAL_IDX,
+            )
+        metal_faces.update(set(bm.faces) - before)
 
         pack_uvs(bm)
         bmesh.ops.recalc_face_normals(bm, faces=list(bm.faces))
@@ -652,13 +869,26 @@ <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">4.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
 
 
@@ -723,87 +953,171 @@ <h2>Source</h2>
     }
 
 
-<span class="k">def</span> mesh_components(me):
-    <span class="s">&quot;&quot;&quot;Per-part AABBs in the construction frame, un-raked so the stiles read
-    axis-aligned. The parts interpenetrate but share no vertices, so edge
-    connectivity separates them.&quot;&quot;&quot;</span>
+<span class="k">def</span> zfight_pairs(me):
+    data = [
+        (p.center.copy(), p.normal.copy(), frozenset(p.vertices))
+        <span class="k">for</span> p <span class="k">in</span> me.polygons
+    ]
+    eps2 = ZFIGHT_EPS * ZFIGHT_EPS
+    count = <span class="n">0</span>
+    <span class="k">for</span> i <span class="k">in</span> range(len(data)):
+        ci, ni, vi = data[i]
+        <span class="k">for</span> j <span class="k">in</span> range(i + <span class="n">1</span>, len(data)):
+            cj, nj, vj = data[j]
+            <span class="k">if</span> (cj - ci).length_squared &gt; eps2:
+                <span class="k">continue</span>
+            <span class="k">if</span> abs(ni.dot(nj)) &lt;= ZFIGHT_COS:
+                <span class="k">continue</span>
+            <span class="k">if</span> vi &amp; vj:
+                <span class="k">continue</span>
+            count += <span class="n">1</span>
+    <span class="k">return</span> count
+
+
+<span class="k">def</span> shell_records(me):
+    <span class="s">&quot;&quot;&quot;One record per edge-connected shell, in world space and un-raked.&quot;&quot;&quot;</span>
     neighbors = [[] <span class="k">for</span> _ <span class="k">in</span> range(len(me.vertices))]
     <span class="k">for</span> edge <span class="k">in</span> me.edges:
-        a, b = edge.vertices
+        a, b = int(edge.vertices[<span class="n">0</span>]), int(edge.vertices[<span class="n">1</span>])
         neighbors[a].append(b)
         neighbors[b].append(a)
     unrake = Euler((-RAKE, <span class="n">0.0</span>, <span class="n">0.0</span>)).to_matrix()
     seen = [<span class="k">False</span>] * len(me.vertices)
-    parts = []
+    groups = []
     <span class="k">for</span> start <span class="k">in</span> range(len(me.vertices)):
         <span class="k">if</span> seen[start]:
             <span class="k">continue</span>
         seen[start] = <span class="k">True</span>
         stack = [start]
-        points = []
+        group = []
         <span class="k">while</span> stack:
             current = stack.pop()
-            points.append(unrake @ me.vertices[current].co)
+            group.append(current)
             <span class="k">for</span> nxt <span class="k">in</span> neighbors[current]:
                 <span class="k">if</span> <span class="k">not</span> seen[nxt]:
                     seen[nxt] = <span class="k">True</span>
                     stack.append(nxt)
-        lo = Vector(
-            (
-                min(p.x <span class="k">for</span> p <span class="k">in</span> points),
-                min(p.y <span class="k">for</span> p <span class="k">in</span> points),
-                min(p.z <span class="k">for</span> p <span class="k">in</span> points),
-            )
-        )
-        hi = Vector(
-            (
-                max(p.x <span class="k">for</span> p <span class="k">in</span> points),
-                max(p.y <span class="k">for</span> p <span class="k">in</span> points),
-                max(p.z <span class="k">for</span> p <span class="k">in</span> points),
-            )
-        )
-        parts.append((lo, hi))
-    <span class="k">return</span> parts
+        groups.append(group)
+    records = []
+    <span class="k">for</span> group <span class="k">in</span> groups:
+        member = set(group)
+        world = [me.vertices[i].co.copy() <span class="k">for</span> i <span class="k">in</span> group]
+        local = [unrake @ p <span class="k">for</span> p <span class="k">in</span> world]
+        mats = {}
+        <span class="k">for</span> poly <span class="k">in</span> me.polygons:
+            <span class="k">if</span> all(v <span class="k">in</span> member <span class="k">for</span> v <span class="k">in</span> poly.vertices):
+                mats[poly.material_index] = mats.get(poly.material_index, <span class="n">0</span>) + <span class="n">1</span>
+        mat = max(mats, key=mats.get) <span class="k">if</span> mats <span class="k">else</span> -<span class="n">1</span>
+        records.append({<span class="s">&quot;world&quot;</span>: world, <span class="s">&quot;local&quot;</span>: local, <span class="s">&quot;mat&quot;</span>: mat})
+    <span class="k">return</span> records
+
+
+<span class="k">def</span> _span_at(pts, z):
+    <span class="s">&quot;&quot;&quot;X extent of a ruled stile at height z, from the end rings.
+
+    Bevel does not add vertices along the rail, so the section is the
+    linear blend of the two end widths.
+    &quot;&quot;&quot;</span>
+    z0 = min(p.z <span class="k">for</span> p <span class="k">in</span> pts)
+    z1 = max(p.z <span class="k">for</span> p <span class="k">in</span> pts)
+    <span class="k">if</span> z1 - z0 &lt; <span class="n">1e-6</span>:
+        <span class="k">return</span> <span class="k">None</span>
+    bot = [p <span class="k">for</span> p <span class="k">in</span> pts <span class="k">if</span> p.z &lt;= z0 + <span class="n">0.015</span>]
+    top = [p <span class="k">for</span> p <span class="k">in</span> pts <span class="k">if</span> p.z &gt;= z1 - <span class="n">0.015</span>]
+    <span class="k">if</span> len(bot) &lt; <span class="n">2</span> <span class="k">or</span> len(top) &lt; <span class="n">2</span>:
+        <span class="k">return</span> <span class="k">None</span>
+    t = min(<span class="n">1.0</span>, max(<span class="n">0.0</span>, (z - z0) / (z1 - z0)))
+    x0 = (<span class="n">1.0</span> - t) * min(p.x <span class="k">for</span> p <span class="k">in</span> bot) + t * min(p.x <span class="k">for</span> p <span class="k">in</span> top)
+    x1 = (<span class="n">1.0</span> - t) * max(p.x <span class="k">for</span> p <span class="k">in</span> bot) + t * max(p.x <span class="k">for</span> p <span class="k">in</span> top)
+    <span class="k">return</span> x0, x1
 
 
 <span class="k">def</span> joint_audit(me):
-    <span class="s">&quot;&quot;&quot;Worst-case rung-to-stile fit, recomputed from vertex positions.&quot;&quot;&quot;</span>
-    parts = mesh_components(me)
-    stiles = [p <span class="k">for</span> p <span class="k">in</span> parts <span class="k">if</span> (p[<span class="n">1</span>].z - p[<span class="n">0</span>].z) &gt; STILE_H * <span class="n">0.8</span>]
-    rungs = [p <span class="k">for</span> p <span class="k">in</span> parts <span class="k">if</span> (p[<span class="n">1</span>].x - p[<span class="n">0</span>].x) &gt; SPAN]
-    <span class="k">if</span> len(stiles) != <span class="n">2</span> <span class="k">or</span> len(rungs) != N_RUNGS:
-        <span class="k">return</span> {
-            <span class="s">&quot;parts&quot;</span>: len(parts),
-            <span class="s">&quot;stiles&quot;</span>: len(stiles),
-            <span class="s">&quot;rungs&quot;</span>: len(rungs),
-            <span class="s">&quot;clearance&quot;</span>: -<span class="n">1.0</span>,
-            <span class="s">&quot;engage&quot;</span>: -<span class="n">1.0</span>,
-            <span class="s">&quot;breakout&quot;</span>: -<span class="n">1.0</span>,
-        }
-    left = min(stiles, key=<span class="k">lambda</span> p: p[<span class="n">0</span>].x)
-    right = max(stiles, key=<span class="k">lambda</span> p: p[<span class="n">0</span>].x)
-    clearance = min(
-        min(
-            (stile[<span class="n">1</span>].y - stile[<span class="n">0</span>].y) - (rung[<span class="n">1</span>].y - rung[<span class="n">0</span>].y)
-            <span class="k">for</span> stile <span class="k">in</span> (left, right)
-        )
-        * <span class="n">0.5</span>
-        <span class="k">for</span> rung <span class="k">in</span> rungs
-    )
-    engage = min(
-        min(left[<span class="n">1</span>].x - rung[<span class="n">0</span>].x, rung[<span class="n">1</span>].x - right[<span class="n">0</span>].x) <span class="k">for</span> rung <span class="k">in</span> rungs
-    )
-    breakout = min(
-        min(rung[<span class="n">0</span>].x - left[<span class="n">0</span>].x, right[<span class="n">1</span>].x - rung[<span class="n">1</span>].x) <span class="k">for</span> rung <span class="k">in</span> rungs
-    )
-    <span class="k">return</span> {
-        <span class="s">&quot;parts&quot;</span>: len(parts),
+    <span class="s">&quot;&quot;&quot;Rung tenon fit and shoe seat, recomputed from vertex positions.&quot;&quot;&quot;</span>
+    recs = shell_records(me)
+    stiles = []
+    rungs = []
+    bands = []
+    soles = []
+    <span class="k">for</span> rec <span class="k">in</span> recs:
+        loc = rec[<span class="s">&quot;local&quot;</span>]
+        zs = [p.z <span class="k">for</span> p <span class="k">in</span> loc]
+        xs = [p.x <span class="k">for</span> p <span class="k">in</span> loc]
+        dz = max(zs) - min(zs)
+        dx = max(xs) - min(xs)
+        wz = [p.z <span class="k">for</span> p <span class="k">in</span> rec[<span class="s">&quot;world&quot;</span>]]
+        wz0 = min(wz)
+        wdz = max(wz) - wz0
+        <span class="k">if</span> rec[<span class="s">&quot;mat&quot;</span>] == WOOD_IDX <span class="k">and</span> dz &gt; <span class="n">0.8</span>:
+            stiles.append(rec)
+        <span class="k">elif</span> rec[<span class="s">&quot;mat&quot;</span>] == WOOD_IDX <span class="k">and</span> dx &gt; <span class="n">0.2</span>:
+            rungs.append(rec)
+        <span class="k">elif</span> rec[<span class="s">&quot;mat&quot;</span>] == METAL_IDX <span class="k">and</span> wz0 &lt; <span class="n">0.004</span> <span class="k">and</span> wdz &lt; SOLE_H + <span class="n">0.01</span>:
+            soles.append(rec)
+        <span class="k">elif</span> rec[<span class="s">&quot;mat&quot;</span>] == METAL_IDX <span class="k">and</span> min(zs) &lt; <span class="n">0.08</span> <span class="k">and</span> dz &lt; <span class="n">0.12</span>:
+            bands.append(rec)
+    empty = {
+        <span class="s">&quot;parts&quot;</span>: len(recs),
         <span class="s">&quot;stiles&quot;</span>: len(stiles),
         <span class="s">&quot;rungs&quot;</span>: len(rungs),
+        <span class="s">&quot;bands&quot;</span>: len(bands),
+        <span class="s">&quot;soles&quot;</span>: len(soles),
+        <span class="s">&quot;clearance&quot;</span>: -<span class="n">1.0</span>,
+        <span class="s">&quot;engage&quot;</span>: -<span class="n">1.0</span>,
+        <span class="s">&quot;breakout&quot;</span>: -<span class="n">1.0</span>,
+        <span class="s">&quot;shoe_bite&quot;</span>: -<span class="n">1.0</span>,
+        <span class="s">&quot;shoe_cover&quot;</span>: -<span class="n">1.0</span>,
+        <span class="s">&quot;rail_zmin&quot;</span>: -<span class="n">1.0</span>,
+        <span class="s">&quot;sole_zmin&quot;</span>: <span class="n">1.0</span>,
+    }
+    <span class="k">if</span> len(stiles) != <span class="n">2</span> <span class="k">or</span> len(rungs) != N_RUNGS <span class="k">or</span> len(bands) != <span class="n">2</span> <span class="k">or</span> len(soles) != <span class="n">2</span>:
+        <span class="k">return</span> empty
+    clearance = <span class="n">1e9</span>
+    engage = <span class="n">1e9</span>
+    breakout = <span class="n">1e9</span>
+    <span class="k">for</span> rung <span class="k">in</span> rungs:
+        rz = sum(p.z <span class="k">for</span> p <span class="k">in</span> rung[<span class="s">&quot;local&quot;</span>]) / len(rung[<span class="s">&quot;local&quot;</span>])
+        rx0 = min(p.x <span class="k">for</span> p <span class="k">in</span> rung[<span class="s">&quot;local&quot;</span>])
+        rx1 = max(p.x <span class="k">for</span> p <span class="k">in</span> rung[<span class="s">&quot;local&quot;</span>])
+        <span class="k">for</span> stile <span class="k">in</span> stiles:
+            span = _span_at(stile[<span class="s">&quot;local&quot;</span>], rz)
+            <span class="k">if</span> span <span class="k">is</span> <span class="k">None</span>:
+                <span class="k">return</span> empty
+            x0, x1 = span
+            inside = [p <span class="k">for</span> p <span class="k">in</span> rung[<span class="s">&quot;local&quot;</span>] <span class="k">if</span> x0 + <span class="n">0.003</span> &lt; p.x &lt; x1 - <span class="n">0.003</span>]
+            <span class="k">if</span> len(inside) &lt; <span class="n">3</span>:
+                <span class="k">return</span> empty
+            stile_dy = max(p.y <span class="k">for</span> p <span class="k">in</span> stile[<span class="s">&quot;local&quot;</span>]) - min(p.y <span class="k">for</span> p <span class="k">in</span> stile[<span class="s">&quot;local&quot;</span>])
+            rung_dy = max(p.y <span class="k">for</span> p <span class="k">in</span> inside) - min(p.y <span class="k">for</span> p <span class="k">in</span> inside)
+            clearance = min(clearance, (stile_dy - rung_dy) * <span class="n">0.5</span>)
+            <span class="k">if</span> x1 &lt; <span class="n">0.0</span>:
+                engage = min(engage, x1 - rx0)
+                breakout = min(breakout, rx0 - x0)
+            <span class="k">else</span>:
+                engage = min(engage, rx1 - x0)
+                breakout = min(breakout, x1 - rx1)
+    shoe_bite = <span class="n">1e9</span>
+    shoe_cover = <span class="n">1e9</span>
+    <span class="k">for</span> stile <span class="k">in</span> stiles:
+        sx = sum(p.x <span class="k">for</span> p <span class="k">in</span> stile[<span class="s">&quot;local&quot;</span>]) / len(stile[<span class="s">&quot;local&quot;</span>])
+        band = min(bands, key=<span class="k">lambda</span> b: abs(sum(p.x <span class="k">for</span> p <span class="k">in</span> b[<span class="s">&quot;local&quot;</span>]) / len(b[<span class="s">&quot;local&quot;</span>]) - sx))
+        stile_z0 = min(p.z <span class="k">for</span> p <span class="k">in</span> stile[<span class="s">&quot;local&quot;</span>])
+        band_z0 = min(p.z <span class="k">for</span> p <span class="k">in</span> band[<span class="s">&quot;local&quot;</span>])
+        band_z1 = max(p.z <span class="k">for</span> p <span class="k">in</span> band[<span class="s">&quot;local&quot;</span>])
+        shoe_bite = min(shoe_bite, stile_z0 - band_z0)
+        shoe_cover = min(shoe_cover, band_z1 - stile_z0)
+    rail_zmin = min(min(p.z <span class="k">for</span> p <span class="k">in</span> s[<span class="s">&quot;world&quot;</span>]) <span class="k">for</span> s <span class="k">in</span> stiles)
+    sole_zmin = max(min(p.z <span class="k">for</span> p <span class="k">in</span> s[<span class="s">&quot;world&quot;</span>]) <span class="k">for</span> s <span class="k">in</span> soles)
+    empty.update({
         <span class="s">&quot;clearance&quot;</span>: clearance,
         <span class="s">&quot;engage&quot;</span>: engage,
         <span class="s">&quot;breakout&quot;</span>: breakout,
-    }
+        <span class="s">&quot;shoe_bite&quot;</span>: shoe_bite,
+        <span class="s">&quot;shoe_cover&quot;</span>: shoe_cover,
+        <span class="s">&quot;rail_zmin&quot;</span>: rail_zmin,
+        <span class="s">&quot;sole_zmin&quot;</span>: sole_zmin,
+    })
+    <span class="k">return</span> empty
 
 
 <span class="k">def</span> add_stray_vert(me):
@@ -937,16 +1251,33 @@ <h2>Source</h2>
     )
 
 
-<span class="k">def</span> check(skip_decimate, lift_z=<span class="k">False</span>, stray_vert=<span class="k">False</span>, fat_rungs=<span class="k">False</span>):
+<span class="k">def</span> check(
+    skip_decimate,
+    lift_z=<span class="k">False</span>,
+    stray_vert=<span class="k">False</span>,
+    fat_rungs=<span class="k">False</span>,
+    short_stile=<span class="k">False</span>,
+    twin_sole=<span class="k">False</span>,
+):
     bpy.ops.wm.read_factory_settings(use_empty=<span class="k">True</span>)
-    <span class="c"># Falsification: a dowel as deep as the stile, which is what used to break</span>
-    <span class="c"># through the front and back chamfers.</span>
+    <span class="c"># Falsification: a tenon as deep as the stile, which breaks the front</span>
+    <span class="c"># and back chamfers. The barrel stays outside the stile.</span>
     rung_radius = STILE_D / <span class="n">2.0</span> <span class="k">if</span> fat_rungs <span class="k">else</span> RUNG_R
     low = build_ladder_mesh(
-        <span class="s">&quot;LadderLow&quot;</span>, bevel_offset=<span class="n">0.0025</span>, bevel_segments=<span class="n">2</span>, rung_radius=rung_radius
+        <span class="s">&quot;LadderLow&quot;</span>,
+        bevel_offset=<span class="n">0.0022</span>,
+        bevel_segments=<span class="n">2</span>,
+        rung_radius=rung_radius,
+        short_stile=short_stile,
+        twin_sole=twin_sole,
     )
     high = build_ladder_mesh(
-        <span class="s">&quot;LadderHigh&quot;</span>, bevel_offset=<span class="n">0.0025</span>, bevel_segments=<span class="n">4</span>, rung_radius=rung_radius
+        <span class="s">&quot;LadderHigh&quot;</span>,
+        bevel_offset=<span class="n">0.0022</span>,
+        bevel_segments=<span class="n">4</span>,
+        rung_radius=rung_radius,
+        short_stile=short_stile,
+        twin_sole=twin_sole,
     )
     <span class="k">if</span> lift_z:
         low.location.z += LIFT_Z
@@ -955,8 +1286,22 @@ <h2>Source</h2>
     <span class="c"># world_bbox reads matrix_world, which is evaluated data. Without this the</span>
     <span class="c"># cached matrix hides a moved object and the grounded budget cannot fail.</span>
     bpy.context.view_layer.update()
-    wood = principled(<span class="s">&quot;LadderWood&quot;</span>, (<span class="n">0.42</span>, <span class="n">0.24</span>, <span class="n">0.10</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.55</span>)
-    metal = principled(<span class="s">&quot;LadderMetal&quot;</span>, (<span class="n">0.48</span>, <span class="n">0.46</span>, <span class="n">0.42</span>, <span class="n">1.0</span>), <span class="n">1.0</span>, <span class="n">0.28</span>)
+    wood = principled(
+        <span class="s">&quot;LadderWood&quot;</span>,
+        (<span class="n">0.40</span>, <span class="n">0.22</span>, <span class="n">0.09</span>, <span class="n">1.0</span>),
+        <span class="n">0.0</span>,
+        <span class="n">0.62</span>,
+        noise_scale=<span class="n">9.0</span>,
+        wear=(<span class="n">0.28</span>, <span class="n">0.15</span>, <span class="n">0.06</span>, <span class="n">1.0</span>),
+    )
+    metal = principled(
+        <span class="s">&quot;LadderMetal&quot;</span>,
+        (<span class="n">0.18</span>, <span class="n">0.175</span>, <span class="n">0.16</span>, <span class="n">1.0</span>),
+        <span class="n">1.0</span>,
+        <span class="n">0.48</span>,
+        noise_scale=<span class="n">18.0</span>,
+        wear=(<span class="n">0.10</span>, <span class="n">0.09</span>, <span class="n">0.08</span>, <span class="n">1.0</span>),
+    )
     assign_slots(low, wood, metal)
     assign_slots(high, wood, metal)
 
@@ -1024,16 +1369,21 @@ <h2>Source</h2>
         <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>
     )
     hyg = hygiene_audit(low.data)
+    zf = zfight_pairs(low.data)
     print(
         <span class="s">f&quot;</span><span class="s">measured hygiene loose_v=</span>{hyg[<span class="s">&#x27;loose_v&#x27;</span>]}<span class="s"> loose_e=</span>{hyg[<span class="s">&#x27;loose_e&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
         <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>
+        <span class="s">f&quot;</span><span class="s">doubles=</span>{hyg[<span class="s">&#x27;doubles&#x27;</span>]}<span class="s"> ngons=</span>{hyg[<span class="s">&#x27;ngons&#x27;</span>]}<span class="s"> zfight=</span>{zf}<span class="s"> </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">euler=</span>{hyg[<span class="s">&#x27;euler&#x27;</span>]}<span class="s">&quot;</span>
     )
     joint = joint_audit(low.data)
     print(
         <span class="s">f&quot;</span><span class="s">measured joints parts=</span>{joint[<span class="s">&#x27;parts&#x27;</span>]}<span class="s"> stiles=</span>{joint[<span class="s">&#x27;stiles&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
-        <span class="s">f&quot;</span><span class="s">rungs=</span>{joint[<span class="s">&#x27;rungs&#x27;</span>]}<span class="s"> clearance=</span>{joint[<span class="s">&#x27;clearance&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> </span><span class="s">&quot;</span>
-        <span class="s">f&quot;</span><span class="s">engage=</span>{joint[<span class="s">&#x27;engage&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> breakout=</span>{joint[<span class="s">&#x27;breakout&#x27;</span>]:<span class="s">.5f</span>}<span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">rungs=</span>{joint[<span class="s">&#x27;rungs&#x27;</span>]}<span class="s"> bands=</span>{joint[<span class="s">&#x27;bands&#x27;</span>]}<span class="s"> soles=</span>{joint[<span class="s">&#x27;soles&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">clearance=</span>{joint[<span class="s">&#x27;clearance&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> engage=</span>{joint[<span class="s">&#x27;engage&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">breakout=</span>{joint[<span class="s">&#x27;breakout&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> shoe_bite=</span>{joint[<span class="s">&#x27;shoe_bite&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">shoe_cover=</span>{joint[<span class="s">&#x27;shoe_cover&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> rail_zmin=</span>{joint[<span class="s">&#x27;rail_zmin&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">sole_zmin=</span>{joint[<span class="s">&#x27;sole_zmin&#x27;</span>]:<span class="s">.5f</span>}<span class="s">&quot;</span>
     )
 
     <span class="k">if</span> <span class="k">not</span> (BASE_TRIS_MIN &lt;= base_tris &lt;= BASE_TRIS_MAX):
@@ -1106,11 +1456,13 @@ <h2>Source</h2>
         <span class="k">or</span> hyg[<span class="s">&quot;zero_area&quot;</span>]
         <span class="k">or</span> hyg[<span class="s">&quot;doubles&quot;</span>]
         <span class="k">or</span> hyg[<span class="s">&quot;ngons&quot;</span>]
+        <span class="k">or</span> zf
     ):
         <span class="k">return</span> fail(
             <span class="s">f&quot;</span><span class="s">hygiene loose_v=</span>{hyg[<span class="s">&#x27;loose_v&#x27;</span>]}<span class="s"> loose_e=</span>{hyg[<span class="s">&#x27;loose_e&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
             <span class="s">f&quot;</span><span class="s">nonman=</span>{hyg[<span class="s">&#x27;nonman&#x27;</span>]}<span class="s"> zero_area=</span>{hyg[<span class="s">&#x27;zero_area&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
-            <span class="s">f&quot;</span><span class="s">doubles=</span>{hyg[<span class="s">&#x27;doubles&#x27;</span>]}<span class="s"> ngons=</span>{hyg[<span class="s">&#x27;ngons&#x27;</span>]}<span class="s">&quot;</span>,
+            <span class="s">f&quot;</span><span class="s">doubles=</span>{hyg[<span class="s">&#x27;doubles&#x27;</span>]}<span class="s"> ngons=</span>{hyg[<span class="s">&#x27;ngons&#x27;</span>]}<span class="s"> zfight=</span>{zf}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">&quot;(--stray-vert / --twin-sole are the designed fails)&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:
@@ -1119,6 +1471,11 @@ <h2>Source</h2>
             <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> abs(joint[<span class="s">&quot;sole_zmin&quot;</span>]) &gt; ZMIN_EPS <span class="k">or</span> joint[<span class="s">&quot;rail_zmin&quot;</span>] &lt; RAIL_ZMIN_MIN:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">sole_zmin </span>{joint[<span class="s">&#x27;sole_zmin&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> rail_zmin </span>{joint[<span class="s">&#x27;rail_zmin&#x27;</span>]:<span class="s">.5f</span>}<span class="s">&quot;</span>,
+            <span class="n">16</span>,
+        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
     <span class="k">if</span> joint[<span class="s">&quot;parts&quot;</span>] != PART_COUNT:
         <span class="k">return</span> fail(
             <span class="s">f&quot;</span><span class="s">part count </span>{joint[<span class="s">&#x27;parts&#x27;</span>]}<span class="s"> != </span>{PART_COUNT}<span class="s"> </span><span class="s">&quot;</span>
@@ -1142,6 +1499,12 @@ <h2>Source</h2>
             <span class="s">f&quot;</span>{TENON_BREAKOUT_MIN}<span class="s">&quot;</span>,
             <span class="n">17</span>,
         ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+    <span class="k">if</span> joint[<span class="s">&quot;shoe_bite&quot;</span>] &lt; SHOE_BITE_MIN <span class="k">or</span> joint[<span class="s">&quot;shoe_cover&quot;</span>] &lt; SHOE_COVER_MIN:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">shoe bite </span>{joint[<span class="s">&#x27;shoe_bite&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> cover </span>{joint[<span class="s">&#x27;shoe_cover&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">&quot;(--short-stile is the designed fail)&quot;</span>,
+            <span class="n">18</span>,
+        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
     <span class="k">return</span> <span class="n">0</span>, low, high, wood, tex, collider
 
 
@@ -1274,7 +1637,17 @@ <h2>Source</h2>
     p.add_argument(
         <span class="s">&quot;--fat-rungs&quot;</span>,
         action=<span class="s">&quot;store_true&quot;</span>,
-        help=<span class="s">&quot;falsification: dowels as deep as the stile, failing joint fit&quot;</span>,
+        help=<span class="s">&quot;falsification: tenons as deep as the stile, failing joint fit&quot;</span>,
+    )
+    p.add_argument(
+        <span class="s">&quot;--short-stile&quot;</span>,
+        action=<span class="s">&quot;store_true&quot;</span>,
+        help=<span class="s">&quot;falsification: rails start above the shoe sleeve&quot;</span>,
+    )
+    p.add_argument(
+        <span class="s">&quot;--twin-sole&quot;</span>,
+        action=<span class="s">&quot;store_true&quot;</span>,
+        help=<span class="s">&quot;falsification: duplicate a sole so a coplanar pair z-fights&quot;</span>,
     )
     args = p.parse_args(argv)
 
@@ -1283,6 +1656,8 @@ <h2>Source</h2>
         lift_z=args.lift_z,
         stray_vert=args.stray_vert,
         fat_rungs=args.fat_rungs,
+        short_stile=args.short_stile,
+        twin_sole=args.twin_sole,
     )
     <span class="k">if</span> code:
         <span class="k">return</span> code
diff --git a/showcase/README.md b/showcase/README.md
index 39401186..e8e8b5e1 100644
--- a/showcase/README.md
+++ b/showcase/README.md
@@ -38,7 +38,11 @@ entry in `showcase/gallery.json`, and a rendered still.
   15), `--lift-z` the grounded-zmin falsifier (exit 16), and
   `--fat-rungs` (or the piece's equivalent) the joint-fit falsifier
   (exit 17), and `--round-band` (or equivalent) the seat-conformance
-  falsifier (exit 18). A budget with no falsifier witnesses nothing:
+  falsifier (exit 18). `--twin-sole` duplicates a ground plate so the
+  coplanar-face budget fails (exit 15). `--short-stile` /
+  `--short-post` lift a member out of its cup (exit 18 or 19).
+  `--clip-ring` pulls a hung ring off the eye centerline (exit 18).
+  A budget with no falsifier witnesses nothing:
   prove each one fails once, and check the exit code, not just
   non-zero.
 - **Hygiene budgets.** Copied combinatorics from
@@ -92,8 +96,24 @@ entry in `showcase/gallery.json`, and a rendered still.
   inner versus outer vertices against the host surface at each vertex's
   own angle. A global midpoint radius misclassifies outer chamfer
   vertices as inner ones the moment the host is out of round, which is
-  how a hoop that visibly gapped on one side still passed. The paired
+  how a hoop that visibly gapped on one side still passed.   The paired
   falsifier makes the wrapper a true circle on an out-of-round host.
+- **Level sole on a raked leg (exit 18).** A raked stile does not sit
+  in a world-axis cube. Build the sleeve in the member frame so it
+  follows the rake; add the tread after the rake as its own
+  axis-aligned plate, from Z=0 up to a height that covers the tilted
+  sleeve. The member end stays inside the sleeve by a named bite and
+  above the tread. `--short-stile` starts the member above the sleeve
+  so the bite fails while the AABB zmin still passes.
+- **Hung ring (exit 18).** A hitching ring is a torus whose center is
+  the eye center plus the hang direction times the major radius, so
+  the eye lies on the ring centerline, and the tube is thinner than
+  the eye's inner radius. The shank stops in the top of the eye tube;
+  continuing it to the eye center runs the pin through the ring. A
+  torus parked on a face is not a hung ring. `--clip-ring` lifts the
+  ring off that centerline. `--short-post` starts the post above the
+  shoe cup so the seated-post budget fails (exit 19) while the sole
+  still grounds the AABB.
 - **Sampled host seat (exit 17/18 on scatter).** Instanced scatter
   seats by sampling the host surface Z at each instance's XY, biting a
   named depth, then clamping instance verts above the slab floor. A
diff --git a/showcase/gallery.json b/showcase/gallery.json
index 682f2630..6d6750d4 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 (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.",
+      "teaches": "A procedural hitching post (eaved cap, one rail, cup shoe, rings hung through eyes) through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.",
+      "witnessesFix": "Recomputed: 1680 tris, two materials with 114 wood and 742 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.500×0.149×1.246 m, zmin 0, hygiene and coplanar pairs 0, post seated at z 0.010, ring centerline error 0, LOD ratios in band, convex collider 80 tris, non-empty glTF. --skip-decimate exits 9; --stray-vert and --twin-sole exit 15; --lift-z exits 16; --clip-ring exits 18; --short-post exits 19.",
       "hero": "docs/gallery/assets/hitching-post-hero.webp",
       "preview": "showcase/hitching-post/preview.webp",
       "tags": [
@@ -296,8 +296,8 @@
     {
       "name": "wooden-ladder",
       "dir": "showcase/wooden-ladder",
-      "teaches": "A procedural timber ladder with raked stiles, six dowel rungs tenoned into the stiles, and iron shoes and top caps through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.",
-      "witnessesFix": "Recomputed: 936 tris, two materials with 324 wood and 216 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.472×0.365×1.460 m, grounded at zmin 0, mesh hygiene all zero, 12 shells with every rung clearing the stile chamfer by 3.61 mm, convex collider 24 tris, non-empty glTF. Four falsifiers exit 9, 15, 16, and 17 on the LOD, hygiene, grounded, and joint-fit budgets.",
+      "teaches": "A procedural timber ladder with raked tapered stiles, six turned rungs, ferrule caps, and level shoe plates through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.",
+      "witnessesFix": "Recomputed: 2536 tris, two materials with 612 wood and 736 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.490×0.376×1.487 m, zmin 0, hygiene and coplanar pairs 0, tenon clearance 8 mm, shoe bite 20 mm, LOD ratios in band, convex collider 24 tris, non-empty glTF. --skip-decimate exits 9; --stray-vert and --twin-sole exit 15; --lift-z exits 16; --fat-rungs exits 17; --short-stile exits 18.",
       "hero": "docs/gallery/assets/wooden-ladder-hero.webp",
       "preview": "showcase/wooden-ladder/preview.webp",
       "tags": [
diff --git a/showcase/hitching-post/README.md b/showcase/hitching-post/README.md
index 6185bb8b..d7354fcc 100644
--- a/showcase/hitching-post/README.md
+++ b/showcase/hitching-post/README.md
@@ -1,24 +1,24 @@
 # Hitching post
 
-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.
+A showcase piece, not an example. Procedural timber hitching post: a
+125 mm square post seated in a closed iron shoe, one cross-rail through
+the post, a pyramidal cap with eaves, and two rings hung through eyes
+under the rail. 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.
 
+Intended size: post 0.125 m square and 1.16 m of timber, cap 0.096 m,
+cross-rail 0.50 m. Outer AABB 0.500 × 0.149 × 1.246 m.
+
 **Composes** skills `mesh-editing-and-bmesh`, `bake-high-to-low`,
 `depsgraph-and-evaluated-data`, `engine-export-presets`, and snippets
 `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.
+imported). Coplanar-pair counting matches `showcase/signpost`.
 
 ## Budgets
 
@@ -27,39 +27,62 @@ materials, UVs, evaluated LOD, collider, or export file.
 
 | 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 |
+| Base triangles | 1400–2400 | 1680 / 1680 / 1680 |
+| LOD1 ratio | 0.32–0.62 of base | 0.5000 / 0.5000 / 0.5000 |
 | 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 |
+| Materials | exactly 2 distinct, ≥70 wood, ≥560 metal | 2 slots, 114 wood, 742 metal |
 | UVs | in `0..1`, 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) |
+| Outer AABB | (0.500, 0.149, 1.246) m ± 0.01 | (0.5000, 0.1490, 1.2460) |
 | 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 |
+| Hygiene | loose/nonman/zero-area/doubles/n-gons/coplanar pairs = 0 | all 0 |
+| Post seat | world zmin in (0.004, 0.014), XY centroid within 0.010 of origin, arm axis cos ≥ cos(0.5°) | 0.01000, 0, 1.000 |
+| Hung ring | centerline error ≤ 0.008 m, ring–wood overlap 0, eye–wood overlap 0, shank–ring overlap 0, shank bites the eye | 0, 0, 0, 0, 40 |
+| Shoe | each band overlaps the post, shoe overlaps the sole | band gap 0, sole–shoe 8 |
+| Wood–metal gap | BVH surface < 0.008 m | 0.00075 |
+| Collider tris | ≤ 280 | 80 |
+| Export | written, size > 0 | 127428 / 127428 / 127412 bytes |
+
+Base triangles rose from **1598 to 1680**. The old rings were faceted
+tori clipped into the arm; the new eyes, shanks, and 24-segment hung
+rings replace that mesh. Cylinder caps are triangulated so the n-gon
+budget stays at 0.
 
 DECIMATE COLLAPSE triangle counts are **not** identical across series —
-the gate is a ratio band, not an exact count. Bake pixels are
-stochastic; the gate is `has_data` plus operator `FINISHED`, not
-byte-identity. Construction uses no RNG. Export byte counts differ by
-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.
+the gate is a ratio band, not an exact count. On this mesh the three
+binaries agreed. 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 is 12 (six balls and seven tori) and is not gated to 2.
+
+Each falsifier violates exactly one named budget. Proven on Blender
+4.5.11 LTS, 5.1.2, and 5.2.1 LTS (the binaries' own `--version`):
+
+| Falsifier | Budget violated | Exit | Measured failure |
+| --- | --- | --- | --- |
+| `--skip-decimate` | LOD1 ratio band | 9 | ratio 1.0000 |
+| `--stray-vert` | Mesh hygiene, loose verts | 15 | `loose_v=1` |
+| `--twin-sole` | Coplanar face pairs | 15 | `zfight=6` |
+| `--lift-z` | Grounded zmin | 16 | zmin 0.050000 |
+| `--clip-ring` | Hung-ring centerline | 18 | ring_err 0.024, ring–wood overlap 32 |
+| `--short-post` | Seated post | 19 | post zmin 0.030 |
 
-`--skip-decimate` skips the LOD DECIMATE stage so LOD1 ratio is 1.0 and
-exit 9 fires. `--lift-z` raises the mesh 5 cm so the grounded-zmin
-hygiene budget fails and exit 16 fires.
+Default exit is 0 on all three. `--clip-ring` also overlaps the rail;
+the centerline gate is the one that fires.
 
 ## Run
 
 ```bash
 blender --background --python hitching_post.py --
 blender --background --python hitching_post.py -- --skip-decimate
+blender --background --python hitching_post.py -- --stray-vert
+blender --background --python hitching_post.py -- --twin-sole
 blender --background --python hitching_post.py -- --lift-z
-blender --background --python hitching_post.py -- --output hitching-post.png
+blender --background --python hitching_post.py -- --clip-ring
+blender --background --python hitching_post.py -- --short-post
+blender --background --python hitching_post.py -- --output preview.webp --engine cycles
 ```
 
-Smoke does not pass `--output`, `--skip-decimate`, or `--lift-z`.
+Smoke does not pass `--output` or a falsifier.
 
 ## Exit codes
 
@@ -83,6 +106,8 @@ File-local. `9` is a valid check code. `10` is reserved for
 | 12 | Bake did not finish or image has no data |
 | 13 | Export file missing or empty |
 | 14 | `--output` produced no file |
-| 15 | Hygiene: loose verts/edges, non-manifold, zero-area, doubles, or n-gons |
-| 16 | Grounded zmin (`--lift-z` lands here) |
+| 15 | Hygiene, including coplanar pairs (`--stray-vert`, `--twin-sole`) |
+| 16 | Grounded zmin (`--lift-z`) |
 | 17 | Wood–metal BVH gap above 8 mm |
+| 18 | Hung ring or shoe seat (`--clip-ring`) |
+| 19 | Post plumb, origin, and cup seat (`--short-post`) |
diff --git a/showcase/hitching-post/hitching_post.py b/showcase/hitching-post/hitching_post.py
index 4d9f8394..95e663c8 100644
--- a/showcase/hitching-post/hitching_post.py
+++ b/showcase/hitching-post/hitching_post.py
@@ -9,7 +9,11 @@
 Budgets are declared below and recomputed from the generated result.
 They are not API-contract witnesses. ``--skip-decimate`` skips the LOD
 DECIMATE stage so the LOD-ratio budget fails. ``--lift-z`` raises the
-mesh so the grounded-zmin hygiene budget fails.
+mesh so the grounded-zmin budget fails. ``--stray-vert`` adds one loose
+vertex so the hygiene budget fails. ``--twin-sole`` duplicates the shoe
+plate so the coplanar-face budget fails. ``--clip-ring`` lifts a hung
+ring off the eye centerline. ``--short-post`` starts the post above the
+shoe cup so the seated-post budget fails.
 
 No RNG. Construction is closed-form. DECIMATE COLLAPSE triangle counts
 are not byte-identical across Blender versions — the LOD gate is a
@@ -18,6 +22,10 @@
     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 -- --stray-vert
+    blender --background --python hitching_post.py -- --twin-sole
+    blender --background --python hitching_post.py -- --clip-ring
+    blender --background --python hitching_post.py -- --short-post
     blender --background --python hitching_post.py -- --output hitching-post.png
 """
 import argparse
@@ -41,28 +49,37 @@
 
 POST_W = 0.125
 POST_H = 1.16
-CAP_H = 0.10
-CAP_EMBED = 0.002
-SHOE_H = 0.055
-SHOE_T = 0.014
-SHOE_SCALE = 1.38
-ARM_Z = 0.90
-ARM_L = 0.46
+CAP_H = 0.096
+CAP_OVERHANG = 0.010
+CAP_EMBED = 0.010
+SOLE_T = 0.016
+POST_BITE = 0.006
+SHOE_H = 0.064
+SHOE_T = 0.012
+ARM_Z = 0.88
+ARM_L = 0.50
 ARM_Y = 0.056
-ARM_ZTH = 0.056
-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)
+ARM_ZTH = 0.050
+EYE_MAJOR = 0.016
+EYE_MINOR = 0.0045
+RING_MAJOR = 0.038
+RING_MINOR = 0.0065
+EYE_X = 0.162
+BAND_H = 0.026
+BAND_T = 0.008
+BAND_ZS = (0.24, 0.56)
+# Ring tube must fit through the eye: RING_MINOR < EYE_MAJOR - EYE_MINOR.
+RING_FIT = 0.004
+POST_ZMIN_LO = 0.004
+POST_ZMIN_HI = 0.014
+RING_CENTER_TOL = 0.008
+AXIS_COS_MIN = math.cos(math.radians(0.5))
+POST_XY_MAX = 0.010
 
 BBOX_TOL = 0.01
-OUTER_SIZE = (0.460, 0.191, 1.258)
-BASE_TRIS_MIN = 900
-BASE_TRIS_MAX = 1800
+OUTER_SIZE = (0.500, 0.149, 1.246)
+BASE_TRIS_MIN = 1400
+BASE_TRIS_MAX = 2400
 LOD1_RATIO_MIN = 0.32
 LOD1_RATIO_MAX = 0.62
 LOD2_RATIO_MIN = 0.10
@@ -75,11 +92,13 @@
 COLLIDER_TRIS_MAX = 280
 BAKE_RES = 256
 CAGE_EXTRUSION = 0.08
-METAL_FACES_MIN = 24
-WOOD_FACES_MIN = 12
+METAL_FACES_MIN = 560
+WOOD_FACES_MIN = 70
 ZMIN_EPS = 1e-4
 DOUBLES_EPS = 1e-5
 AREA_EPS = 1e-10
+ZFIGHT_EPS = 0.002
+ZFIGHT_COS = 0.98
 GAP_MAX = 0.008
 LIFT_Z = 0.05
 
@@ -155,7 +174,7 @@ def add_cyl(bm, loc, radius, depth, segments, mat_idx, euler=(0.0, 0.0, 0.0)):
     geo = bmesh.ops.create_cone(
         bm,
         cap_ends=True,
-        cap_tris=False,
+        cap_tris=True,
         segments=segments,
         radius1=radius,
         radius2=radius,
@@ -305,6 +324,241 @@ def hygiene_audit(me):
     }
 
 
+def zfight_pairs(me):
+    # Same pair test as showcase/signpost (copied, not imported).
+    data = [
+        (p.center.copy(), p.normal.copy(), frozenset(p.vertices))
+        for p in me.polygons
+    ]
+    eps2 = ZFIGHT_EPS * ZFIGHT_EPS
+    count = 0
+    for i in range(len(data)):
+        ci, ni, vi = data[i]
+        for j in range(i + 1, len(data)):
+            cj, nj, vj = data[j]
+            if (cj - ci).length_squared > eps2:
+                continue
+            if abs(ni.dot(nj)) <= ZFIGHT_COS:
+                continue
+            if vi & vj:
+                continue
+            count += 1
+    return count
+
+
+def _face_shells(me):
+    parent = list(range(len(me.vertices)))
+
+    def find(a):
+        while parent[a] != a:
+            parent[a] = parent[parent[a]]
+            a = parent[a]
+        return a
+
+    def union(a, b):
+        ra, rb = find(a), find(b)
+        if ra != rb:
+            parent[rb] = ra
+
+    for edge in me.edges:
+        union(int(edge.vertices[0]), int(edge.vertices[1]))
+    groups = {}
+    for i in range(len(me.vertices)):
+        groups.setdefault(find(i), []).append(i)
+    shells = []
+    for idxs in groups.values():
+        want = set(idxs)
+        polys = [
+            p.index
+            for p in me.polygons
+            if all(v in want for v in p.vertices)
+        ]
+        if polys:
+            shells.append((idxs, polys))
+    return shells
+
+
+def _bounds(me, idxs):
+    xs, ys, zs = [], [], []
+    for i in idxs:
+        co = me.vertices[i].co
+        xs.append(co.x)
+        ys.append(co.y)
+        zs.append(co.z)
+    return min(xs), max(xs), min(ys), max(ys), min(zs), max(zs)
+
+
+def _centroid(me, idxs):
+    acc = Vector()
+    for i in idxs:
+        acc += me.vertices[i].co
+    return acc / float(len(idxs))
+
+
+def _majority_mat(me, poly_ids):
+    counts = {}
+    for i in poly_ids:
+        mat = me.polygons[i].material_index
+        counts[mat] = counts.get(mat, 0) + 1
+    return max(counts, key=counts.get)
+
+
+def _bvh(me, poly_ids):
+    remap = {}
+    verts = []
+    faces = []
+    for pi in poly_ids:
+        face = []
+        for vi in me.polygons[pi].vertices:
+            if vi not in remap:
+                remap[vi] = len(verts)
+                verts.append(me.vertices[vi].co.copy())
+            face.append(remap[vi])
+        faces.append(face)
+    return BVHTree.FromPolygons(verts, faces)
+
+
+def seat_audit(me):
+    """Recompute cup, hung-ring, and plumb budgets from the generated shells."""
+    post = arm = cap = None
+    soles, rings, eyes, bands, shanks = [], [], [], [], []
+    for idxs, polys in _face_shells(me):
+        x0, x1, y0, y1, z0, z1 = _bounds(me, idxs)
+        dx, dy, dz = x1 - x0, y1 - y0, z1 - z0
+        rec = {
+            "idxs": idxs,
+            "polys": polys,
+            "c": _centroid(me, idxs),
+            "z0": z0,
+        }
+        if _majority_mat(me, polys) == WOOD_IDX:
+            if dz > 0.5 and dx < 0.30:
+                post = rec
+            elif dx > 0.30:
+                arm = rec
+            else:
+                cap = rec
+            continue
+        if z0 < 0.004 and dz < 0.030 and dx > 0.10:
+            soles.append(rec)
+        elif dy < 0.025 and dx > 0.06 and dz > 0.06:
+            rings.append(rec)
+        elif dx < 0.025 and dy > 0.025 and dz > 0.02:
+            eyes.append(rec)
+        elif dx < 0.030 and dy < 0.030 and dz < 0.08:
+            shanks.append(rec)
+        else:
+            bands.append(rec)
+
+    out = {
+        "post": int(post is not None),
+        "arm": int(arm is not None),
+        "cap": int(cap is not None),
+        "soles": len(soles),
+        "rings": len(rings),
+        "eyes": len(eyes),
+        "bands": len(bands),
+        "post_zmin": -1.0,
+        "post_xy": 99.0,
+        "arm_cos": 0.0,
+        "ring_err": 99.0,
+        "ring_wood": 99,
+        "eye_wood": 99,
+        "band_gap": 99.0,
+        "sole_shoe": 0,
+        "shanks": 0,
+        "shank_ring": 99,
+        "shank_eye": 0,
+    }
+    if (
+        post is None
+        or arm is None
+        or cap is None
+        or len(rings) != 2
+        or len(eyes) != 2
+        or len(bands) < 3
+        or len(shanks) != 2
+        or not soles
+    ):
+        return out
+
+    wood_bvh = _bvh(me, post["polys"] + arm["polys"] + cap["polys"])
+    ring_wood = 0
+    eye_wood = 0
+    ring_err = 0.0
+    for eye, ring in zip(
+        sorted(eyes, key=lambda r: r["c"].x),
+        sorted(rings, key=lambda r: r["c"].x),
+    ):
+        ring_err = max(ring_err, abs((ring["c"] - eye["c"]).length - RING_MAJOR))
+        ring_wood += len(wood_bvh.overlap(_bvh(me, ring["polys"])))
+        eye_wood += len(wood_bvh.overlap(_bvh(me, eye["polys"])))
+
+    shank_ring = 0
+    shank_eye = 0
+    for shank in shanks:
+        shank_bvh = _bvh(me, shank["polys"])
+        for ring in rings:
+            shank_ring += len(shank_bvh.overlap(_bvh(me, ring["polys"])))
+        eye = min(eyes, key=lambda rec: abs(rec["c"].x - shank["c"].x))
+        shank_eye += len(shank_bvh.overlap(_bvh(me, eye["polys"])))
+
+    band_gap = 0.0
+    for band in bands:
+        if wood_bvh.overlap(_bvh(me, band["polys"])):
+            continue
+        dmin = 1.0e9
+        for i in band["idxs"]:
+            hit = wood_bvh.find_nearest(me.vertices[i].co)
+            if hit[3] is not None:
+                dmin = min(dmin, hit[3])
+        band_gap = max(band_gap, dmin)
+
+    shoe = min(bands, key=lambda b: b["z0"])
+    sole_shoe = len(_bvh(me, soles[0]["polys"]).overlap(_bvh(me, shoe["polys"])))
+
+    pos, neg = [], []
+    for i in arm["idxs"]:
+        co = me.vertices[i].co
+        if co.x > 0.12:
+            pos.append(co)
+        elif co.x < -0.12:
+            neg.append(co)
+    if pos and neg:
+        a = sum(pos, Vector()) / len(pos)
+        b = sum(neg, Vector()) / len(neg)
+        arm_cos = abs((a - b).normalized().dot(Vector((1.0, 0.0, 0.0))))
+    else:
+        arm_cos = 0.0
+
+    out.update({
+        "post_zmin": post["z0"],
+        "post_xy": math.hypot(post["c"].x, post["c"].y),
+        "arm_cos": arm_cos,
+        "ring_err": ring_err,
+        "ring_wood": ring_wood,
+        "eye_wood": eye_wood,
+        "band_gap": band_gap,
+        "sole_shoe": sole_shoe,
+        "shanks": len(shanks),
+        "shank_ring": shank_ring,
+        "shank_eye": shank_eye,
+    })
+    return out
+
+
+def add_stray_vert(me):
+    # Inside the post so the bbox budget still passes and hygiene is the gate.
+    bm = bmesh.new()
+    try:
+        bm.from_mesh(me)
+        bm.verts.new((0.0, 0.0, POST_H * 0.5))
+        bm.to_mesh(me)
+        me.update()
+    finally:
+        bm.free()
+
+
 def min_mat_distance(me, ia, ib):
     """Closest surface distance between two material islands via BVH."""
     bm_a = bmesh.new()
@@ -383,63 +637,71 @@ def pack_uvs(bm, margin=0.08):
             )
 
 
-def build_hitching_post_mesh(name, bevel_offset, bevel_segments):
+def add_torus(bm, center, major, minor, axis, mat_idx, n_major=24, n_minor=8):
+    """Torus whose hole points along `axis`. The loop lies in the perpendicular plane."""
+    axis = Vector(axis).normalized()
+    tmp = Vector((0.0, 0.0, 1.0)) if abs(axis.z) < 0.85 else Vector((1.0, 0.0, 0.0))
+    u = axis.cross(tmp).normalized()
+    v = axis.cross(u).normalized()
+    origin = Vector(center)
+    rings = []
+    for i in range(n_major):
+        a = i * (2.0 * math.pi / n_major)
+        radial = u * math.cos(a) + v * math.sin(a)
+        ring = []
+        for j in range(n_minor):
+            b = j * (2.0 * math.pi / n_minor)
+            point = origin + radial * (major + minor * math.cos(b)) + axis * (minor * math.sin(b))
+            ring.append(bm.verts.new(point))
+        rings.append(ring)
+    bm.verts.ensure_lookup_table()
+    made = []
+    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
+            made.append(rings[i][j])
+    return made
+
+
+def build_hitching_post_mesh(
+    name,
+    bevel_offset,
+    bevel_segments,
+    short_post=False,
+    clip_ring=False,
+    twin_sole=False,
+    small_cap=False,
+):
+    """Post on a closed shoe, one rail, rings hung through eyes under the rail.
+
+    The ring center is the eye center plus (0, 0, -RING_MAJOR), so the eye
+    sits on the ring centerline. The eye hangs below the rail; the shank
+    is bitten into the rail.
+    """
     bm = bmesh.new()
     try:
+        half = POST_W * 0.5
+        post_z0 = (SOLE_T + 0.014) if short_post else (SOLE_T - POST_BITE)
         wood = []
-        half = POST_W / 2.0
-        cap_r = half * math.sqrt(2.0)
-
         wood.extend(
             add_box(
                 bm,
-                (0.0, 0.0, POST_H / 2.0),
-                (POST_W, POST_W, POST_H),
-                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 - CAP_EMBED),
-                cap_r,
-                0.008,
-                CAP_H,
-                4,
+                (0.0, 0.0, (post_z0 + POST_H) * 0.5),
+                (POST_W, POST_W, POST_H - post_z0),
                 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),
-                (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),
+                (ARM_L, 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 if v.is_valid})
             ret = bmesh.ops.bevel(
@@ -451,58 +713,90 @@ def build_hitching_post_mesh(name, bevel_offset, bevel_segments):
                 affect="EDGES",
                 clamp_overlap=True,
             )
-            for f in ret.get("faces") or []:
-                f.material_index = WOOD_IDX
+            for face in ret.get("faces") or []:
+                face.material_index = WOOD_IDX
+
+        cap_r = (half * 0.55) if small_cap else (half + CAP_OVERHANG) * math.sqrt(2.0)
+        add_cone(
+            bm,
+            (0.0, 0.0, POST_H + CAP_H * 0.5 - CAP_EMBED),
+            cap_r,
+            0.004,
+            CAP_H,
+            4,
+            WOOD_IDX,
+            euler=(0.0, 0.0, math.pi / 4.0),
+        )
 
-        # 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)
+        grip = bevel_offset + 0.0015
+        sole_w = POST_W + 2.0 * SHOE_T
+        add_box(
+            bm,
+            (0.0, 0.0, SOLE_T * 0.5),
+            (sole_w, sole_w, SOLE_T),
+            METAL_IDX,
+        )
+        if twin_sole:
+            add_box(
+                bm,
+                (0.0012, 0.0012, SOLE_T * 0.5),
+                (sole_w, sole_w, SOLE_T),
+                METAL_IDX,
+            )
+        wall_z0 = SOLE_T - 0.003
+        wall_z1 = SHOE_H
+        add_square_band(
+            bm,
+            0.5 * (wall_z0 + wall_z1),
+            half - grip,
+            SHOE_T,
+            wall_z1 - wall_z0,
+            METAL_IDX,
+        )
         for z in BAND_ZS:
-            add_square_band(bm, z, half - 0.002, BAND_T, BAND_H, METAL_IDX)
-
-        arm_y_face = -(ARM_Y / 2.0)
-        for sx in (-ARM_L * 0.32, ARM_L * 0.32):
-            # Eye on the -Y arm face; hitching ring threads it (YZ vs XZ).
-            add_rim(
+            add_square_band(bm, z, half - grip, BAND_T, BAND_H, METAL_IDX)
+
+        arm_bottom = ARM_Z - ARM_ZTH * 0.5
+        eye_z = arm_bottom - EYE_MAJOR - EYE_MINOR - 0.004
+        # Shank stops in the top of the eye tube. Continuing it to the eye
+        # center runs the pin through the hung ring.
+        shank_bot = eye_z + EYE_MAJOR - 0.002
+        shank_top = arm_bottom + 0.012
+        shank_h = shank_top - shank_bot
+        ring_lift = 0.024 if clip_ring else 0.0
+        for sx in (-EYE_X, EYE_X):
+            add_cyl(
+                bm,
+                (sx, 0.0, shank_bot + shank_h * 0.5),
+                EYE_MINOR * 0.9,
+                shank_h,
+                8,
+                METAL_IDX,
+            )
+            add_torus(
                 bm,
-                (sx, arm_y_face + EYE_MINOR * 0.25, ARM_Z),
+                (sx, 0.0, eye_z),
                 EYE_MAJOR,
                 EYE_MINOR,
+                (1.0, 0.0, 0.0),
                 METAL_IDX,
-                euler=(math.pi / 2.0, 0.0, 0.0),
-                n_major=14,
-                n_minor=7,
+                n_major=16,
+                n_minor=8,
             )
-            add_rim(
+            add_torus(
                 bm,
-                (
-                    sx,
-                    arm_y_face - RING_MAJOR * 0.55,
-                    ARM_Z - RING_MAJOR * 0.28,
-                ),
+                (sx, 0.0, eye_z - RING_MAJOR + ring_lift),
                 RING_MAJOR,
                 RING_MINOR,
+                (0.0, 1.0, 0.0),
                 METAL_IDX,
-                euler=(0.0, math.pi / 2.0, 0.0),
-                n_major=18,
+                n_major=24,
                 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]
-        rcx = 0.5 * (min(xs) + max(xs))
-        rcy = 0.5 * (min(ys) + max(ys))
         zmin = min(zs)
         for v in bm.verts:
-            v.co.x -= rcx
-            v.co.y -= rcy
             v.co.z -= zmin
             if v.co.z < 0.0:
                 v.co.z = 0.0
@@ -510,10 +804,7 @@ 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:
-            if face.material_index == METAL_IDX:
-                face.smooth = True
-            else:
-                face.smooth = False
+            face.smooth = face.material_index == METAL_IDX
         for edge in bm.edges:
             if not edge.is_manifold or len(edge.link_faces) != 2:
                 continue
@@ -530,7 +821,6 @@ def build_hitching_post_mesh(name, bevel_offset, bevel_segments):
     bpy.context.collection.objects.link(out)
     return out
 
-
 def principled(name, color, metallic, roughness, noise_scale=0.0, wear=None):
     mat = bpy.data.materials.new(name)
     mat.use_nodes = True
@@ -682,9 +972,23 @@ def export_unity(path, objects):
     )
 
 
-def check(skip_decimate, lift_z=False):
+def check(
+    skip_decimate,
+    lift_z=False,
+    stray_vert=False,
+    twin_sole=False,
+    clip_ring=False,
+    short_post=False,
+):
     bpy.ops.wm.read_factory_settings(use_empty=True)
-    low = build_hitching_post_mesh("HitchPostLow", bevel_offset=0.008, bevel_segments=2)
+    low = build_hitching_post_mesh(
+        "HitchPostLow",
+        bevel_offset=0.008,
+        bevel_segments=2,
+        short_post=short_post,
+        clip_ring=clip_ring,
+        twin_sole=twin_sole,
+    )
     high = build_hitching_post_mesh("HitchPostHigh", bevel_offset=0.008, bevel_segments=4)
     wood = principled(
         "HitchPostWood",
@@ -694,13 +998,22 @@ def check(skip_decimate, lift_z=False):
         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)
+    metal = principled(
+        "HitchPostIron",
+        (0.16, 0.155, 0.15, 1.0),
+        1.0,
+        0.48,
+        noise_scale=16.0,
+        wear=(0.09, 0.085, 0.08, 1.0),
+    )
     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 stray_vert:
+        add_stray_vert(low.data)
 
     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
@@ -762,7 +1075,9 @@ def check(skip_decimate, lift_z=False):
         f"outer={OUTER_SIZE} zmin={bb[2]:.4f}"
     )
     hyg = hygiene_audit(low.data)
+    zfight = zfight_pairs(low.data)
     gap = min_mat_distance(low.data, METAL_IDX, WOOD_IDX)
+    seat = seat_audit(low.data)
     print(
         f"measured collider_tris={col_tris} bake={bake_result} "
         f"bake_has_data={img.has_data} export_bytes={export_size}"
@@ -770,9 +1085,19 @@ def check(skip_decimate, lift_z=False):
     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']}"
+        f"doubles={hyg['doubles']} ngons={hyg['ngons']} euler={hyg['euler']} "
+        f"zfight={zfight}"
     )
     print(f"measured wood_metal_gap={gap:.5f} zmin={bb[2]:.6f}")
+    print(
+        f"measured seat post_zmin={seat['post_zmin']:.5f} post_xy={seat['post_xy']:.5f} "
+        f"arm_cos={seat['arm_cos']:.6f} ring_err={seat['ring_err']:.5f} "
+        f"ring_wood={seat['ring_wood']} eye_wood={seat['eye_wood']} "
+        f"band_gap={seat['band_gap']:.5f} sole_shoe={seat['sole_shoe']} "
+        f"shank_ring={seat['shank_ring']} shank_eye={seat['shank_eye']} "
+        f"parts={seat['post']}/{seat['arm']}/{seat['cap']}/"
+        f"soles={seat['soles']}/rings={seat['rings']}/eyes={seat['eyes']}/bands={seat['bands']}"
+    )
 
     if not (BASE_TRIS_MIN <= base_tris <= BASE_TRIS_MAX):
         return fail(
@@ -841,14 +1166,16 @@ def check(skip_decimate, lift_z=False):
         hyg["loose_v"]
         or hyg["loose_e"]
         or hyg["nonman"]
-        or hyg["zero_area"]
+        or         hyg["zero_area"]
         or hyg["doubles"]
         or hyg["ngons"]
+        or zfight
     ):
         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']}",
+            f"doubles={hyg['doubles']} ngons={hyg['ngons']} zfight={zfight} "
+            "(--stray-vert / --twin-sole are the designed fails)",
             15,
         ), None, None, None, None, None
     if abs(bb[2]) > ZMIN_EPS:
@@ -862,6 +1189,39 @@ def check(skip_decimate, lift_z=False):
             f"wood-metal gap {gap:.5f} > {GAP_MAX}",
             17,
         ), None, None, None, None, None
+    if (
+        seat["rings"] != 2
+        or seat["eyes"] != 2
+        or seat["bands"] < 3
+        or seat["soles"] < 1
+        or seat["ring_err"] > RING_CENTER_TOL
+        or seat["ring_wood"]
+        or seat["eye_wood"]
+        or seat["shanks"] != 2
+        or seat["band_gap"] > GAP_MAX
+        or seat["sole_shoe"] < 1
+        or seat["shank_ring"]
+        or seat["shank_eye"] < 1
+    ):
+        return fail(
+            f"hung ring / shoe seat ring_err={seat['ring_err']:.5f} "
+            f"ring_wood={seat['ring_wood']} eye_wood={seat['eye_wood']} "
+            f"band_gap={seat['band_gap']:.5f} sole_shoe={seat['sole_shoe']} "
+            f"shank_ring={seat['shank_ring']} shank_eye={seat['shank_eye']} "
+            "(--clip-ring is the designed fail)",
+            18,
+        ), None, None, None, None, None
+    if (
+        not (POST_ZMIN_LO < seat["post_zmin"] < POST_ZMIN_HI)
+        or seat["post_xy"] > POST_XY_MAX
+        or seat["arm_cos"] < AXIS_COS_MIN
+    ):
+        return fail(
+            f"post seat zmin={seat['post_zmin']:.5f} xy={seat['post_xy']:.5f} "
+            f"arm_cos={seat['arm_cos']:.6f} "
+            "(--short-post is the designed fail)",
+            19,
+        ), None, None, None, None, None
     return 0, low, high, wood, tex, collider
 
 
@@ -985,9 +1345,36 @@ def main():
         action="store_true",
         help="falsification: lift the mesh so zmin fails the grounded budget",
     )
+    p.add_argument(
+        "--stray-vert",
+        action="store_true",
+        help="falsification: one loose vertex so the hygiene budget fails",
+    )
+    p.add_argument(
+        "--twin-sole",
+        action="store_true",
+        help="falsification: duplicate the shoe plate so coplanar faces fail",
+    )
+    p.add_argument(
+        "--clip-ring",
+        action="store_true",
+        help="falsification: lift the rings off the eye centerline",
+    )
+    p.add_argument(
+        "--short-post",
+        action="store_true",
+        help="falsification: start the post above the shoe cup",
+    )
     args = p.parse_args(argv)
 
-    code, low, _high, wood, tex, _col = check(args.skip_decimate, lift_z=args.lift_z)
+    code, low, _high, wood, tex, _col = check(
+        args.skip_decimate,
+        lift_z=args.lift_z,
+        stray_vert=args.stray_vert,
+        twin_sole=args.twin_sole,
+        clip_ring=args.clip_ring,
+        short_post=args.short_post,
+    )
     if code:
         return code
     if args.output:
diff --git a/showcase/hitching-post/preview.webp b/showcase/hitching-post/preview.webp
index 39d5d78f..6954d2a8 100644
Binary files a/showcase/hitching-post/preview.webp and b/showcase/hitching-post/preview.webp differ
diff --git a/showcase/wooden-ladder/README.md b/showcase/wooden-ladder/README.md
index ae0f4be7..52712445 100644
--- a/showcase/wooden-ladder/README.md
+++ b/showcase/wooden-ladder/README.md
@@ -1,18 +1,25 @@
 # Wooden ladder
 
-A showcase piece, not an example. Procedural timber ladder (raked
-stiles, six 26 mm dowel rungs tenoned into the stiles, iron shoes and
-top caps) 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 timber ladder: two stiles
+tapered from 64 mm to 50 mm, raked 12°, six turned rungs (22 mm tenon,
+barrel thicker only in the clear span), iron ferrules at the top, and
+level shoe plates under sleeves that follow the rake. 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.
 
+Intended size: stile length 1.50 m, overall about 0.49 × 0.38 × 1.49 m.
+A household ladder, not a 3 m orchard ladder.
+
 **Composes** skills `mesh-editing-and-bmesh`, `bake-high-to-low`,
 `depsgraph-and-evaluated-data`, `engine-export-presets`, and snippets
 `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). Coplanar-pair counting matches `showcase/signpost`.
 
 ## Budgets
 
@@ -21,54 +28,52 @@ materials, UVs, evaluated LOD, collider, or export file.
 
 | Axis | Declared | Measured (4.5.11 / 5.1.2 / 5.2.1) |
 | --- | --- | --- |
-| Base triangles | 900–975 | 936 / 936 / 936 |
+| Base triangles | 1800–2800 | 2536 / 2536 / 2536 |
 | LOD1 ratio | 0.32–0.62 of base | 0.5000 / 0.5000 / 0.5000 |
-| LOD2 ratio | 0.10–0.35 of base | 0.2179 / 0.2179 / 0.2179 |
-| Materials | exactly 2 distinct, ≥280 wood, ≥180 metal | 2 slots, 324 wood, 216 metal |
+| LOD2 ratio | 0.10–0.35 of base | 0.2192 / 0.2192 / 0.2192 |
+| Materials | exactly 2 distinct, ≥280 wood, ≥180 metal | 2 slots, 612 wood, 736 metal |
 | UVs | in `0..1`, AABB overlap ≤ 1e-5 | in range, overlap 0 |
-| Outer AABB | (0.472, 0.365, 1.460) m ± 0.01 | (0.4720, 0.3649, 1.4597) |
-| Grounded | `abs(zmin)` ≤ 1e-4 | 0.0000 |
-| Mesh hygiene | non-manifold, loose v/e, doubles at 1e-5, zero-area, n-gons all 0 | all 0 |
-| Parts | exactly 12 shells (2 stiles, 6 rungs, 2 caps, 2 shoes) | 12 (2 / 6) |
-| Rung depth clearance | ≥ 0.003 m inside the stile faces | 0.00361 |
-| Tenon engagement | ≥ 0.006 m past the stile inner face | 0.01200 |
-| Tenon breakout margin | ≥ 0.005 m short of the stile outer face | 0.04600 |
-| Collider tris | ≤ 120 | 24 |
-| Export | written, size > 0 | 75140 / 75140 / 75128 bytes |
-
-Base triangles fell from **2184 to 936** in the quality pass: four iron
-fittings per stile collapsed to one shoe and one top cap, and the
-redundant top block came out. No hidden-face removal was involved.
-
-The rung rims are capped and buried in the stile rather than left open.
-That costs 144 tris nobody sees, but an open rim is a non-manifold
-boundary and the hygiene budget forbids it.
+| Outer AABB | (0.490, 0.376, 1.487) m ± 0.01 | (0.4897, 0.3760, 1.4870) |
+| Grounded | `abs(zmin)` ≤ 1e-4, each sole at 0, rail end ≥ 0.012 m | zmin 0, sole 0, rail 0.02037 |
+| Mesh hygiene | non-manifold, loose v/e, doubles at 1e-5, zero-area, n-gons, coplanar pairs all 0 | all 0 |
+| Parts | 16 shells (2 stiles, 6 rungs, 2 sleeves, 2 cap sleeves, 2 plates, 2 soles) | 16 (2 / 6 / 2 / 2) |
+| Rung depth clearance | ≥ 0.003 m inside the stile faces | 0.00800 |
+| Tenon engagement | ≥ 0.008 m past the stile inner face | 0.01399 |
+| Tenon breakout margin | ≥ 0.008 m short of the stile outer face | 0.03780 |
+| Shoe bite / cover | bite ≥ 0.010 m, cover ≥ 0.016 m | 0.02000 / 0.03800 |
+| Collider tris | ≤ 180 | 24 |
+| Export | written, size > 0 | 187528 / 187528 / 187504 bytes |
+
+Base triangles rose from **936 to 2536**. The previous mesh was two
+boxes, six cloned dowels, and four chrome cubes. Turned rungs (tenon
+and barrel in one shell) plus ferrule collars and chamfered soles added
+the triangles. Nothing was removed as a hidden face.
 
 The joint budgets are measured per rung against each stile, from vertex
 positions in the un-raked construction frame, and the reported value is
-the worst case over all twelve rung ends. `clearance` is how far the
-widest dowel stays inside the stile's front and back faces; it must
-exceed the 2.5 mm chamfer or the dowel erupts through it as a spike.
+the worst case. Clearance is the tenon, not the barrel: the barrel is
+thicker only between the stiles.
 
 DECIMATE COLLAPSE triangle counts are **not** identical across series —
 the gate is a ratio band, not an exact count. On this mesh the three
-binaries agreed on LOD ratios. 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.
+binaries agreed. Bake pixels are stochastic; the gate is `has_data`
+plus operator `FINISHED`, not byte-identity. Construction uses no RNG.
+Export byte counts differ by 24 B on 5.2.1 (glTF serializer), not a
+gated axis. Euler is 24 (multi-body) and is not gated to 2.
 
-Each falsifier violates exactly one named budget, and each was proven to
-fire on all three binaries:
+Each falsifier violates exactly one named budget. Proven on Blender
+4.5.11 LTS, 5.1.2, and 5.2.1 LTS (the binaries' own `--version`):
 
 | Falsifier | Budget violated | Exit | Measured failure |
 | --- | --- | --- | --- |
 | `--skip-decimate` | LOD1 ratio band | 9 | ratio 1.0000 |
 | `--stray-vert` | Mesh hygiene, loose verts | 15 | `loose_v=1` |
+| `--twin-sole` | Coplanar face pairs | 15 | `zfight=6` |
 | `--lift-z` | Grounded zmin | 16 | zmin 0.050000 |
-| `--fat-rungs` | Rung depth clearance | 17 | clearance −0.00051 |
+| `--fat-rungs` | Rung depth clearance | 17 | clearance 0 |
+| `--short-stile` | Shoe bite / cover | 18 | bite 0.070, cover −0.012 |
 
-`--fat-rungs` widens the dowels to the full 34 mm stile depth, which is
-the proportion this piece shipped with before the quality pass.
+Default exit is 0 on all three.
 
 ## Run
 
@@ -76,9 +81,11 @@ the proportion this piece shipped with before the quality pass.
 blender --background --python wooden_ladder.py --
 blender --background --python wooden_ladder.py -- --skip-decimate
 blender --background --python wooden_ladder.py -- --stray-vert
+blender --background --python wooden_ladder.py -- --twin-sole
 blender --background --python wooden_ladder.py -- --lift-z
 blender --background --python wooden_ladder.py -- --fat-rungs
-blender --background --python wooden_ladder.py -- --output ladder.png
+blender --background --python wooden_ladder.py -- --short-stile
+blender --background --python wooden_ladder.py -- --output preview.webp --engine cycles
 ```
 
 Smoke passes no flags: no `--output`, no falsifier.
@@ -105,6 +112,7 @@ 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 | Mesh hygiene (`--stray-vert` lands here) |
-| 16 | World AABB min Z off the floor (`--lift-z` lands here) |
-| 17 | Part count or rung-to-stile joint fit (`--fat-rungs` lands here) |
+| 15 | Mesh hygiene, including coplanar pairs (`--stray-vert`, `--twin-sole`) |
+| 16 | Grounded zmin, or a rail end sitting in the tread (`--lift-z`) |
+| 17 | Part count or rung-to-stile joint fit (`--fat-rungs`) |
+| 18 | Shoe bite / cover (`--short-stile`) |
diff --git a/showcase/wooden-ladder/preview.webp b/showcase/wooden-ladder/preview.webp
index c758379d..2b6c2c42 100644
Binary files a/showcase/wooden-ladder/preview.webp and b/showcase/wooden-ladder/preview.webp differ
diff --git a/showcase/wooden-ladder/wooden_ladder.py b/showcase/wooden-ladder/wooden_ladder.py
index ac3b1a12..b86c9d6f 100644
--- a/showcase/wooden-ladder/wooden_ladder.py
+++ b/showcase/wooden-ladder/wooden_ladder.py
@@ -9,8 +9,11 @@
 named budget: ``--skip-decimate`` skips the LOD DECIMATE stage so the
 LOD-ratio budget fails, ``--lift-z`` moves the mesh off the floor so the
 grounded budget fails, ``--stray-vert`` adds one unconnected vertex so the
-mesh-hygiene budget fails, and ``--fat-rungs`` widens the dowels to the
-full stile depth so the rung-to-stile joint-fit budget fails.
+mesh-hygiene budget fails, ``--twin-sole`` duplicates a shoe plate so the
+coplanar-face budget fails, ``--fat-rungs`` widens the tenons to the full
+stile depth so the rung-to-stile joint-fit budget fails, and
+``--short-stile`` starts the rail above the sleeve so the shoe-bite
+budget fails.
 
 No RNG. Construction is closed-form. DECIMATE COLLAPSE triangle counts
 are not byte-identical across Blender versions — the LOD gate is a
@@ -21,7 +24,9 @@
     blender --background --python wooden_ladder.py -- --lift-z
     blender --background --python wooden_ladder.py -- --stray-vert
     blender --background --python wooden_ladder.py -- --fat-rungs
-    blender --background --python wooden_ladder.py -- --output ladder.png
+    blender --background --python wooden_ladder.py -- --short-stile
+    blender --background --python wooden_ladder.py -- --twin-sole
+    blender --background --python wooden_ladder.py -- --output preview.webp
 """
 import argparse
 import math
@@ -44,42 +49,50 @@
 sys.dont_write_bytecode = True
 import gallery_framing  # noqa: E402
 
-STILE_H = 1.48
-STILE_W = 0.058
-STILE_D = 0.034
-SPAN = 0.34
+STILE_H = 1.50
+STILE_W_BOT = 0.064
+STILE_W_TOP = 0.050
+STILE_D = 0.038
+CENTER = 0.198
 N_RUNGS = 6
-# A 26 mm dowel in a 34 mm stile. Sized so the widest rung still clears the
-# stile's 2.5 mm chamfer by more than a millimetre; at 17 mm the dowel was as
-# deep as the stile and broke through the front and back chamfers as a spike.
-RUNG_R = 0.013
+# Tenon stays inside the chamfer. The visible barrel is wider and stops
+# outside the stile, so the two radii are different stations.
+RUNG_R = 0.011
+BARREL_RATIO = 1.34
 RUNG_SEGS = 12
-RUNG_TENON = 0.012
-RUNG_RADIUS_SCALE = (0.98, 1.02, 0.99, 1.03, 0.97, 1.01)
-RUNG_Z_OFFSETS = (0.0, 0.0015, -0.0010, 0.0010, -0.0015, 0.0)
-TOP_CAP_H = 0.025
-SHOE_H = 0.065
-SHOE_W = 0.074
-SHOE_D = 0.070
+RUNG_TENON = 0.014
+RUNG_BARREL_SCALE = (1.00, 1.16, 0.86, 1.22, 0.82, 1.10)
+RUNG_Z_OFFSETS = (0.0, 0.016, -0.012, 0.014, -0.018, 0.008)
+BAND_Z0 = 0.0
+BAND_H = 0.058
+BAND_T = 0.007
+RAIL_Z0 = 0.020
+CAP_DROP = 0.010
+CAP_RISE = 0.016
+PLATE_H = 0.006
+SOLE_H = 0.032
+SOLE_PAD = 0.008
 RAKE = math.radians(12.0)
 BBOX_TOL = 0.01
-# 2 stiles + 6 rungs + 2 top caps + 2 shoes, each a closed shell.
-PART_COUNT = 12
-# Measured joint contract. Clearance exceeds the 2.5 mm chamfer so the dowel
-# stays on the stile's flat face; engagement keeps the tenon seated; breakout
-# keeps it from reaching the outer face.
+# 2 stiles + 6 rungs + 2 shoe sleeves + 2 cap sleeves + 2 cap plates + 2 soles.
+PART_COUNT = 16
 RUNG_DEPTH_CLEARANCE = 0.003
-TENON_ENGAGE_MIN = 0.006
-TENON_BREAKOUT_MIN = 0.005
+TENON_ENGAGE_MIN = 0.008
+TENON_BREAKOUT_MIN = 0.008
+SHOE_BITE_MIN = 0.010
+SHOE_COVER_MIN = 0.016
+RAIL_ZMIN_MIN = 0.012
 ZMIN_EPS = 1e-4
 DOUBLES_EPS = 1e-5
 AREA_EPS = 1e-10
+ZFIGHT_EPS = 0.002
+ZFIGHT_COS = 0.98
 LIFT_Z = 0.05
 # Fitted after locking geometry. Recomputed from bound_box.
-OUTER_SIZE = (0.472, 0.365, 1.460)
+OUTER_SIZE = (0.490, 0.376, 1.487)
 
-BASE_TRIS_MIN = 900
-BASE_TRIS_MAX = 975
+BASE_TRIS_MIN = 1800
+BASE_TRIS_MAX = 2800
 LOD1_RATIO_MIN = 0.32
 LOD1_RATIO_MAX = 0.62
 LOD2_RATIO_MIN = 0.10
@@ -89,7 +102,7 @@
 MATERIAL_COUNT = 2
 UV_EPS = 1e-4
 UV_OVERLAP_MAX = 1e-5
-COLLIDER_TRIS_MAX = 120
+COLLIDER_TRIS_MAX = 180
 BAKE_RES = 256
 CAGE_EXTRUSION = 0.06
 # The caps and shoes carry far more chamfer than body faces, so a floor above
@@ -167,6 +180,128 @@ def add_cylinder(bm, loc, radius, depth, segments, mat_idx, euler=(0.0, 0.0, 0.0
     return add_cone(bm, loc, radius, radius, depth, segments, mat_idx, euler=euler)
 
 
+def half_w(z):
+    t = min(1.0, max(0.0, z / STILE_H))
+    return 0.5 * (STILE_W_BOT + (STILE_W_TOP - STILE_W_BOT) * t)
+
+
+def inner_x(z, sign):
+    x = sign * CENTER
+    hw = half_w(z)
+    return x + hw if sign < 0.0 else x - hw
+
+
+def add_ruled_box(bm, x, z0, z1, hw0, hw1, hd, mat_idx):
+    """Tapered box. Width is the local X half-extent at each end; depth is constant."""
+
+    def ring(z, hw):
+        return [
+            bm.verts.new((x - hw, -hd, z)),
+            bm.verts.new((x + hw, -hd, z)),
+            bm.verts.new((x + hw, hd, z)),
+            bm.verts.new((x - hw, hd, z)),
+        ]
+
+    bottom = ring(z0, hw0)
+    top = ring(z1, hw1)
+
+    def quad(a, b, c, d):
+        face = bm.faces.new((a, b, c, d))
+        face.material_index = mat_idx
+        return face
+
+    for i in range(4):
+        j = (i + 1) % 4
+        quad(bottom[i], bottom[j], top[j], top[i])
+    quad(bottom[3], bottom[2], bottom[1], bottom[0])
+    quad(top[0], top[1], top[2], top[3])
+    return bottom + top
+
+
+def add_rect_band(bm, zc, cx, hx, hy, tx, ty, h, mat_idx):
+    """Closed rectangular collar, constant section, axis along local Z."""
+    z0 = zc - h * 0.5
+    z1 = zc + h * 0.5
+    inner = (
+        (cx + hx, hy),
+        (cx - hx, hy),
+        (cx - hx, -hy),
+        (cx + hx, -hy),
+    )
+    outer = (
+        (cx + hx + tx, hy + ty),
+        (cx - hx - tx, hy + ty),
+        (cx - hx - tx, -(hy + ty)),
+        (cx + hx + tx, -(hy + ty)),
+    )
+
+    def ring(z, pts):
+        return [bm.verts.new((p[0], p[1], z)) for p in pts]
+
+    i0, o0 = ring(z0, inner), ring(z0, outer)
+    i1, o1 = ring(z1, inner), 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 add_turned_rung(bm, z, x_left, x_right, tenon, r_tenon, r_barrel, segs, mat_idx):
+    """One shell: thin tenon inside each stile, thicker barrel only in the clear span."""
+    xs = (
+        x_left - tenon,
+        x_left - 0.0015,
+        x_left + 0.004,
+        x_right - 0.004,
+        x_right + 0.0015,
+        x_right + tenon,
+    )
+    rs = (r_tenon, r_tenon, r_barrel, r_barrel, r_tenon, r_tenon)
+    rings = []
+    for x, radius in zip(xs, rs):
+        ring = []
+        for i in range(segs):
+            ang = i * (2.0 * math.pi / segs)
+            ring.append(bm.verts.new((
+                x,
+                radius * math.cos(ang),
+                z + radius * math.sin(ang),
+            )))
+        rings.append(ring)
+    bm.verts.ensure_lookup_table()
+
+    def face(verts):
+        poly = bm.faces.new(verts)
+        poly.material_index = mat_idx
+        return poly
+
+    for i in range(len(rings) - 1):
+        for j in range(segs):
+            j2 = (j + 1) % segs
+            face((rings[i][j], rings[i][j2], rings[i + 1][j2], rings[i + 1][j]))
+    for ring, x, radius, outward in (
+        (rings[0], xs[0], rs[0], -1.0),
+        (rings[-1], xs[-1], rs[-1], 1.0),
+    ):
+        cap = bm.verts.new((x, 0.0, z))
+        for j in range(segs):
+            j2 = (j + 1) % segs
+            if outward < 0.0:
+                face((cap, ring[j2], ring[j]))
+            else:
+                face((cap, ring[j], ring[j2]))
+    return [v for ring in rings for v in ring]
+
+
 def pack_uvs(bm, margin=0.08):
     uv = bm.loops.layers.uv.new("UVMap")
     faces = list(bm.faces)
@@ -210,39 +345,55 @@ def pack_uvs(bm, margin=0.08):
             )
 
 
-def build_ladder_mesh(name, bevel_offset, bevel_segments, rung_radius=RUNG_R):
+def build_ladder_mesh(
+    name,
+    bevel_offset,
+    bevel_segments,
+    rung_radius=RUNG_R,
+    short_stile=False,
+    twin_sole=False,
+):
+    """Raked tapered rails, turned rungs, sleeve shoes with level soles.
+
+    The sleeve is built in the rail frame so it follows the rake. The sole
+    is a separate world-level plate the sleeve bites into. The rail ends
+    inside the sleeve, above the sole.
+    """
     bm = bmesh.new()
-    stile_verts = []
     metal_faces = set()
-    metal_verts = []
     try:
-        half = SPAN / 2.0 + STILE_W / 2.0
+        rail_z0 = (BAND_Z0 + BAND_H + 0.012) if short_stile else RAIL_Z0
+        rail_z1 = STILE_H - CAP_DROP
+        stile_verts = []
         for sign in (-1.0, 1.0):
             stile_verts.extend(
-                add_box(
+                add_ruled_box(
                     bm,
-                    (sign * half, 0.0, STILE_H / 2.0),
-                    (STILE_W, STILE_D, STILE_H),
+                    sign * CENTER,
+                    rail_z0,
+                    rail_z1,
+                    half_w(rail_z0),
+                    half_w(rail_z1),
+                    STILE_D * 0.5,
                     WOOD_IDX,
                 )
             )
 
-        z0 = 0.16
-        z1 = STILE_H - 0.14
+        z_lo = 0.22
+        z_hi = STILE_H - 0.20
         for i in range(N_RUNGS):
             t = i / (N_RUNGS - 1)
-            z = z0 + t * (z1 - z0) + RUNG_Z_OFFSETS[i]
-            # Tenons stop inside the stile, so the rung rims never reach the
-            # chamfered outer face. Rungs stay unbeveled: they are already
-            # round, and beveling a cap rim spikes through that chamfer.
-            add_cylinder(
+            z = z_lo + t * (z_hi - z_lo) + RUNG_Z_OFFSETS[i]
+            add_turned_rung(
                 bm,
-                (0.0, 0.0, z),
-                rung_radius * RUNG_RADIUS_SCALE[i],
-                SPAN + 2.0 * RUNG_TENON,
+                z,
+                inner_x(z, -1.0),
+                inner_x(z, 1.0),
+                RUNG_TENON,
+                rung_radius,
+                rung_radius * BARREL_RATIO * RUNG_BARREL_SCALE[i],
                 RUNG_SEGS,
                 WOOD_IDX,
-                euler=(0.0, math.pi / 2.0, 0.0),
             )
 
         if bevel_offset > 0.0:
@@ -266,25 +417,85 @@ def build_ladder_mesh(name, bevel_offset, bevel_segments, rung_radius=RUNG_R):
                 )
 
         before = set(bm.faces)
+        metal_verts = []
+        hd = STILE_D * 0.5
         for sign in (-1.0, 1.0):
-            hx = sign * half
+            x = sign * CENTER
+            shoe_z = BAND_Z0 + BAND_H * 0.5
+            grip = 0.0015 + bevel_offset
+            metal_verts.extend(
+                add_rect_band(
+                    bm,
+                    shoe_z,
+                    x,
+                    half_w(shoe_z) - grip,
+                    hd - grip,
+                    BAND_T,
+                    BAND_T,
+                    BAND_H,
+                    METAL_IDX,
+                )
+            )
+            cap_h = CAP_RISE + 0.006
+            cap_z = rail_z1 + (CAP_RISE - 0.006) * 0.5
+            chw = half_w(rail_z1)
+            metal_verts.extend(
+                add_rect_band(
+                    bm,
+                    cap_z,
+                    x,
+                    chw - grip,
+                    hd - grip,
+                    BAND_T,
+                    BAND_T,
+                    cap_h,
+                    METAL_IDX,
+                )
+            )
+            # Plate overlaps the sleeve top so the two faces are not coplanar.
+            plate_z = rail_z1 + CAP_RISE - 0.002 + PLATE_H * 0.5
             metal_verts.extend(
                 add_box(
                     bm,
-                    (hx, 0.0, STILE_H - TOP_CAP_H * 0.30),
-                    (STILE_W + 0.010, STILE_D + 0.010, TOP_CAP_H),
+                    (x, 0.0, plate_z),
+                    (
+                        (chw + BAND_T) * 2.0 + 0.006,
+                        (hd + BAND_T) * 2.0 + 0.006,
+                        PLATE_H,
+                    ),
                     METAL_IDX,
                 )
             )
         metal_faces.update(set(bm.faces) - before)
 
+        if bevel_offset > 0.0 and metal_verts:
+            metal_edges = list(
+                {
+                    edge
+                    for vertex in metal_verts
+                    for edge in vertex.link_edges
+                    if vertex.is_valid
+                }
+            )
+            if metal_edges:
+                bevelled = bmesh.ops.bevel(
+                    bm,
+                    geom=metal_edges,
+                    offset=min(bevel_offset, 0.0016),
+                    segments=bevel_segments,
+                    profile=0.5,
+                    affect="EDGES",
+                    clamp_overlap=True,
+                )
+                metal_faces.update(bevelled.get("faces") or [])
+
         rake = Euler((RAKE, 0.0, 0.0)).to_matrix()
         for v in bm.verts:
             v.co = rake @ v.co
         zs = [v.co.z for v in bm.verts]
-        zmin = min(zs)
         xs = [v.co.x for v in bm.verts]
         ys = [v.co.y for v in bm.verts]
+        zmin = min(zs)
         cx = 0.5 * (min(xs) + max(xs))
         cy = 0.5 * (min(ys) + max(ys))
         for v in bm.verts:
@@ -292,51 +503,60 @@ def build_ladder_mesh(name, bevel_offset, bevel_segments, rung_radius=RUNG_R):
             v.co.y -= cy
             v.co.z -= zmin
 
+        def world_of(local):
+            q = rake @ Vector(local)
+            q.x -= cx
+            q.y -= cy
+            q.z -= zmin
+            return q
+
         before = set(bm.faces)
+        sole_centers = []
+        sole_verts = []
         for sign in (-1.0, 1.0):
-            bottom = rake @ Vector((sign * half, 0.0, 0.0))
-            bottom.x -= cx
-            bottom.y -= cy
-            bottom.z -= zmin
-            metal_verts.extend(
+            x = sign * CENTER
+            shoe_z = BAND_Z0 + BAND_H * 0.5
+            sole_w = (half_w(shoe_z) + BAND_T + SOLE_PAD) * 2.0
+            sole_d = (hd + BAND_T + SOLE_PAD) * 2.0
+            anchor = world_of((x, 0.0, 0.0))
+            sole_centers.append((anchor.x, anchor.y, sole_w, sole_d))
+            sole_verts.extend(
                 add_box(
                     bm,
-                    (bottom.x, bottom.y, SHOE_H / 2.0),
-                    (SHOE_W, SHOE_D, SHOE_H),
+                    (anchor.x, anchor.y, SOLE_H * 0.5),
+                    (sole_w, sole_d, SOLE_H),
                     METAL_IDX,
                 )
             )
-        metal_faces.update(set(bm.faces) - before)
-
-        if bevel_offset > 0.0:
-            metal_edges = list(
+        if bevel_offset > 0.0 and sole_verts:
+            sole_edges = list(
                 {
                     edge
-                    for vertex in metal_verts
+                    for vertex in sole_verts
                     for edge in vertex.link_edges
                     if vertex.is_valid
                 }
             )
-            if metal_edges:
-                # Bevel does not inherit material_index onto the faces it
-                # creates, so claim them from the op's own return rather than
-                # from a pre-bevel face snapshot. Without this every chamfer
-                # on a cap or shoe falls back to slot 0 and renders as wood.
+            if sole_edges:
                 bevelled = bmesh.ops.bevel(
                     bm,
-                    geom=metal_edges,
-                    offset=min(bevel_offset, 0.002),
-                    segments=bevel_segments,
+                    geom=sole_edges,
+                    offset=min(bevel_offset, 0.0014),
+                    segments=1,
                     profile=0.5,
                     affect="EDGES",
                     clamp_overlap=True,
                 )
                 metal_faces.update(bevelled.get("faces") or [])
-
-        ys = [v.co.y for v in bm.verts]
-        final_cy = 0.5 * (min(ys) + max(ys))
-        for v in bm.verts:
-            v.co.y -= final_cy
+        if twin_sole and sole_centers:
+            sx, sy, sw, sd = sole_centers[0]
+            add_box(
+                bm,
+                (sx + 0.0012, sy + 0.0012, SOLE_H * 0.5),
+                (sw, sd, SOLE_H),
+                METAL_IDX,
+            )
+        metal_faces.update(set(bm.faces) - before)
 
         pack_uvs(bm)
         bmesh.ops.recalc_face_normals(bm, faces=list(bm.faces))
@@ -360,13 +580,26 @@ def build_ladder_mesh(name, bevel_offset, bevel_segments, rung_radius=RUNG_R):
     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 = 4.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
 
 
@@ -431,87 +664,171 @@ def hygiene_audit(me):
     }
 
 
-def mesh_components(me):
-    """Per-part AABBs in the construction frame, un-raked so the stiles read
-    axis-aligned. The parts interpenetrate but share no vertices, so edge
-    connectivity separates them."""
+def zfight_pairs(me):
+    data = [
+        (p.center.copy(), p.normal.copy(), frozenset(p.vertices))
+        for p in me.polygons
+    ]
+    eps2 = ZFIGHT_EPS * ZFIGHT_EPS
+    count = 0
+    for i in range(len(data)):
+        ci, ni, vi = data[i]
+        for j in range(i + 1, len(data)):
+            cj, nj, vj = data[j]
+            if (cj - ci).length_squared > eps2:
+                continue
+            if abs(ni.dot(nj)) <= ZFIGHT_COS:
+                continue
+            if vi & vj:
+                continue
+            count += 1
+    return count
+
+
+def shell_records(me):
+    """One record per edge-connected shell, in world space and un-raked."""
     neighbors = [[] for _ in range(len(me.vertices))]
     for edge in me.edges:
-        a, b = edge.vertices
+        a, b = int(edge.vertices[0]), int(edge.vertices[1])
         neighbors[a].append(b)
         neighbors[b].append(a)
     unrake = Euler((-RAKE, 0.0, 0.0)).to_matrix()
     seen = [False] * len(me.vertices)
-    parts = []
+    groups = []
     for start in range(len(me.vertices)):
         if seen[start]:
             continue
         seen[start] = True
         stack = [start]
-        points = []
+        group = []
         while stack:
             current = stack.pop()
-            points.append(unrake @ me.vertices[current].co)
+            group.append(current)
             for nxt in neighbors[current]:
                 if not seen[nxt]:
                     seen[nxt] = True
                     stack.append(nxt)
-        lo = Vector(
-            (
-                min(p.x for p in points),
-                min(p.y for p in points),
-                min(p.z for p in points),
-            )
-        )
-        hi = Vector(
-            (
-                max(p.x for p in points),
-                max(p.y for p in points),
-                max(p.z for p in points),
-            )
-        )
-        parts.append((lo, hi))
-    return parts
+        groups.append(group)
+    records = []
+    for group in groups:
+        member = set(group)
+        world = [me.vertices[i].co.copy() for i in group]
+        local = [unrake @ p for p in world]
+        mats = {}
+        for poly in me.polygons:
+            if all(v in member for v in poly.vertices):
+                mats[poly.material_index] = mats.get(poly.material_index, 0) + 1
+        mat = max(mats, key=mats.get) if mats else -1
+        records.append({"world": world, "local": local, "mat": mat})
+    return records
+
+
+def _span_at(pts, z):
+    """X extent of a ruled stile at height z, from the end rings.
+
+    Bevel does not add vertices along the rail, so the section is the
+    linear blend of the two end widths.
+    """
+    z0 = min(p.z for p in pts)
+    z1 = max(p.z for p in pts)
+    if z1 - z0 < 1e-6:
+        return None
+    bot = [p for p in pts if p.z <= z0 + 0.015]
+    top = [p for p in pts if p.z >= z1 - 0.015]
+    if len(bot) < 2 or len(top) < 2:
+        return None
+    t = min(1.0, max(0.0, (z - z0) / (z1 - z0)))
+    x0 = (1.0 - t) * min(p.x for p in bot) + t * min(p.x for p in top)
+    x1 = (1.0 - t) * max(p.x for p in bot) + t * max(p.x for p in top)
+    return x0, x1
 
 
 def joint_audit(me):
-    """Worst-case rung-to-stile fit, recomputed from vertex positions."""
-    parts = mesh_components(me)
-    stiles = [p for p in parts if (p[1].z - p[0].z) > STILE_H * 0.8]
-    rungs = [p for p in parts if (p[1].x - p[0].x) > SPAN]
-    if len(stiles) != 2 or len(rungs) != N_RUNGS:
-        return {
-            "parts": len(parts),
-            "stiles": len(stiles),
-            "rungs": len(rungs),
-            "clearance": -1.0,
-            "engage": -1.0,
-            "breakout": -1.0,
-        }
-    left = min(stiles, key=lambda p: p[0].x)
-    right = max(stiles, key=lambda p: p[0].x)
-    clearance = min(
-        min(
-            (stile[1].y - stile[0].y) - (rung[1].y - rung[0].y)
-            for stile in (left, right)
-        )
-        * 0.5
-        for rung in rungs
-    )
-    engage = min(
-        min(left[1].x - rung[0].x, rung[1].x - right[0].x) for rung in rungs
-    )
-    breakout = min(
-        min(rung[0].x - left[0].x, right[1].x - rung[1].x) for rung in rungs
-    )
-    return {
-        "parts": len(parts),
+    """Rung tenon fit and shoe seat, recomputed from vertex positions."""
+    recs = shell_records(me)
+    stiles = []
+    rungs = []
+    bands = []
+    soles = []
+    for rec in recs:
+        loc = rec["local"]
+        zs = [p.z for p in loc]
+        xs = [p.x for p in loc]
+        dz = max(zs) - min(zs)
+        dx = max(xs) - min(xs)
+        wz = [p.z for p in rec["world"]]
+        wz0 = min(wz)
+        wdz = max(wz) - wz0
+        if rec["mat"] == WOOD_IDX and dz > 0.8:
+            stiles.append(rec)
+        elif rec["mat"] == WOOD_IDX and dx > 0.2:
+            rungs.append(rec)
+        elif rec["mat"] == METAL_IDX and wz0 < 0.004 and wdz < SOLE_H + 0.01:
+            soles.append(rec)
+        elif rec["mat"] == METAL_IDX and min(zs) < 0.08 and dz < 0.12:
+            bands.append(rec)
+    empty = {
+        "parts": len(recs),
         "stiles": len(stiles),
         "rungs": len(rungs),
+        "bands": len(bands),
+        "soles": len(soles),
+        "clearance": -1.0,
+        "engage": -1.0,
+        "breakout": -1.0,
+        "shoe_bite": -1.0,
+        "shoe_cover": -1.0,
+        "rail_zmin": -1.0,
+        "sole_zmin": 1.0,
+    }
+    if len(stiles) != 2 or len(rungs) != N_RUNGS or len(bands) != 2 or len(soles) != 2:
+        return empty
+    clearance = 1e9
+    engage = 1e9
+    breakout = 1e9
+    for rung in rungs:
+        rz = sum(p.z for p in rung["local"]) / len(rung["local"])
+        rx0 = min(p.x for p in rung["local"])
+        rx1 = max(p.x for p in rung["local"])
+        for stile in stiles:
+            span = _span_at(stile["local"], rz)
+            if span is None:
+                return empty
+            x0, x1 = span
+            inside = [p for p in rung["local"] if x0 + 0.003 < p.x < x1 - 0.003]
+            if len(inside) < 3:
+                return empty
+            stile_dy = max(p.y for p in stile["local"]) - min(p.y for p in stile["local"])
+            rung_dy = max(p.y for p in inside) - min(p.y for p in inside)
+            clearance = min(clearance, (stile_dy - rung_dy) * 0.5)
+            if x1 < 0.0:
+                engage = min(engage, x1 - rx0)
+                breakout = min(breakout, rx0 - x0)
+            else:
+                engage = min(engage, rx1 - x0)
+                breakout = min(breakout, x1 - rx1)
+    shoe_bite = 1e9
+    shoe_cover = 1e9
+    for stile in stiles:
+        sx = sum(p.x for p in stile["local"]) / len(stile["local"])
+        band = min(bands, key=lambda b: abs(sum(p.x for p in b["local"]) / len(b["local"]) - sx))
+        stile_z0 = min(p.z for p in stile["local"])
+        band_z0 = min(p.z for p in band["local"])
+        band_z1 = max(p.z for p in band["local"])
+        shoe_bite = min(shoe_bite, stile_z0 - band_z0)
+        shoe_cover = min(shoe_cover, band_z1 - stile_z0)
+    rail_zmin = min(min(p.z for p in s["world"]) for s in stiles)
+    sole_zmin = max(min(p.z for p in s["world"]) for s in soles)
+    empty.update({
         "clearance": clearance,
         "engage": engage,
         "breakout": breakout,
-    }
+        "shoe_bite": shoe_bite,
+        "shoe_cover": shoe_cover,
+        "rail_zmin": rail_zmin,
+        "sole_zmin": sole_zmin,
+    })
+    return empty
 
 
 def add_stray_vert(me):
@@ -645,16 +962,33 @@ def export_unity(path, objects):
     )
 
 
-def check(skip_decimate, lift_z=False, stray_vert=False, fat_rungs=False):
+def check(
+    skip_decimate,
+    lift_z=False,
+    stray_vert=False,
+    fat_rungs=False,
+    short_stile=False,
+    twin_sole=False,
+):
     bpy.ops.wm.read_factory_settings(use_empty=True)
-    # Falsification: a dowel as deep as the stile, which is what used to break
-    # through the front and back chamfers.
+    # Falsification: a tenon as deep as the stile, which breaks the front
+    # and back chamfers. The barrel stays outside the stile.
     rung_radius = STILE_D / 2.0 if fat_rungs else RUNG_R
     low = build_ladder_mesh(
-        "LadderLow", bevel_offset=0.0025, bevel_segments=2, rung_radius=rung_radius
+        "LadderLow",
+        bevel_offset=0.0022,
+        bevel_segments=2,
+        rung_radius=rung_radius,
+        short_stile=short_stile,
+        twin_sole=twin_sole,
     )
     high = build_ladder_mesh(
-        "LadderHigh", bevel_offset=0.0025, bevel_segments=4, rung_radius=rung_radius
+        "LadderHigh",
+        bevel_offset=0.0022,
+        bevel_segments=4,
+        rung_radius=rung_radius,
+        short_stile=short_stile,
+        twin_sole=twin_sole,
     )
     if lift_z:
         low.location.z += LIFT_Z
@@ -663,8 +997,22 @@ def check(skip_decimate, lift_z=False, stray_vert=False, fat_rungs=False):
     # world_bbox reads matrix_world, which is evaluated data. Without this the
     # cached matrix hides a moved object and the grounded budget cannot fail.
     bpy.context.view_layer.update()
-    wood = principled("LadderWood", (0.42, 0.24, 0.10, 1.0), 0.0, 0.55)
-    metal = principled("LadderMetal", (0.48, 0.46, 0.42, 1.0), 1.0, 0.28)
+    wood = principled(
+        "LadderWood",
+        (0.40, 0.22, 0.09, 1.0),
+        0.0,
+        0.62,
+        noise_scale=9.0,
+        wear=(0.28, 0.15, 0.06, 1.0),
+    )
+    metal = principled(
+        "LadderMetal",
+        (0.18, 0.175, 0.16, 1.0),
+        1.0,
+        0.48,
+        noise_scale=18.0,
+        wear=(0.10, 0.09, 0.08, 1.0),
+    )
     assign_slots(low, wood, metal)
     assign_slots(high, wood, metal)
 
@@ -732,16 +1080,21 @@ def check(skip_decimate, lift_z=False, stray_vert=False, fat_rungs=False):
         f"bake_has_data={img.has_data} export_bytes={export_size}"
     )
     hyg = hygiene_audit(low.data)
+    zf = zfight_pairs(low.data)
     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']}"
+        f"doubles={hyg['doubles']} ngons={hyg['ngons']} zfight={zf} "
+        f"euler={hyg['euler']}"
     )
     joint = joint_audit(low.data)
     print(
         f"measured joints parts={joint['parts']} stiles={joint['stiles']} "
-        f"rungs={joint['rungs']} clearance={joint['clearance']:.5f} "
-        f"engage={joint['engage']:.5f} breakout={joint['breakout']:.5f}"
+        f"rungs={joint['rungs']} bands={joint['bands']} soles={joint['soles']} "
+        f"clearance={joint['clearance']:.5f} engage={joint['engage']:.5f} "
+        f"breakout={joint['breakout']:.5f} shoe_bite={joint['shoe_bite']:.5f} "
+        f"shoe_cover={joint['shoe_cover']:.5f} rail_zmin={joint['rail_zmin']:.5f} "
+        f"sole_zmin={joint['sole_zmin']:.5f}"
     )
 
     if not (BASE_TRIS_MIN <= base_tris <= BASE_TRIS_MAX):
@@ -814,11 +1167,13 @@ def check(skip_decimate, lift_z=False, stray_vert=False, fat_rungs=False):
         or hyg["zero_area"]
         or hyg["doubles"]
         or hyg["ngons"]
+        or zf
     ):
         return fail(
             f"hygiene loose_v={hyg['loose_v']} loose_e={hyg['loose_e']} "
             f"nonman={hyg['nonman']} zero_area={hyg['zero_area']} "
-            f"doubles={hyg['doubles']} ngons={hyg['ngons']}",
+            f"doubles={hyg['doubles']} ngons={hyg['ngons']} zfight={zf} "
+            "(--stray-vert / --twin-sole are the designed fails)",
             15,
         ), None, None, None, None, None
     if abs(bb[2]) > ZMIN_EPS:
@@ -827,6 +1182,11 @@ def check(skip_decimate, lift_z=False, stray_vert=False, fat_rungs=False):
             "(--lift-z is the designed fail)",
             16,
         ), None, None, None, None, None
+    if abs(joint["sole_zmin"]) > ZMIN_EPS or joint["rail_zmin"] < RAIL_ZMIN_MIN:
+        return fail(
+            f"sole_zmin {joint['sole_zmin']:.5f} rail_zmin {joint['rail_zmin']:.5f}",
+            16,
+        ), None, None, None, None, None
     if joint["parts"] != PART_COUNT:
         return fail(
             f"part count {joint['parts']} != {PART_COUNT} "
@@ -850,6 +1210,12 @@ def check(skip_decimate, lift_z=False, stray_vert=False, fat_rungs=False):
             f"{TENON_BREAKOUT_MIN}",
             17,
         ), None, None, None, None, None
+    if joint["shoe_bite"] < SHOE_BITE_MIN or joint["shoe_cover"] < SHOE_COVER_MIN:
+        return fail(
+            f"shoe bite {joint['shoe_bite']:.5f} cover {joint['shoe_cover']:.5f} "
+            "(--short-stile is the designed fail)",
+            18,
+        ), None, None, None, None, None
     return 0, low, high, wood, tex, collider
 
 
@@ -982,7 +1348,17 @@ def main():
     p.add_argument(
         "--fat-rungs",
         action="store_true",
-        help="falsification: dowels as deep as the stile, failing joint fit",
+        help="falsification: tenons as deep as the stile, failing joint fit",
+    )
+    p.add_argument(
+        "--short-stile",
+        action="store_true",
+        help="falsification: rails start above the shoe sleeve",
+    )
+    p.add_argument(
+        "--twin-sole",
+        action="store_true",
+        help="falsification: duplicate a sole so a coplanar pair z-fights",
     )
     args = p.parse_args(argv)
 
@@ -991,6 +1367,8 @@ def main():
         lift_z=args.lift_z,
         stray_vert=args.stray_vert,
         fat_rungs=args.fat_rungs,
+        short_stile=args.short_stile,
+        twin_sole=args.twin_sole,
     )
     if code:
         return code