diff --git a/docs/gallery/assets/tavern-stool-hero.webp b/docs/gallery/assets/tavern-stool-hero.webp
index ce7aad9..d59703a 100644
Binary files a/docs/gallery/assets/tavern-stool-hero.webp and b/docs/gallery/assets/tavern-stool-hero.webp differ
diff --git a/docs/gallery/assets/treasure-chest-hero.webp b/docs/gallery/assets/treasure-chest-hero.webp
index 8bbeffc..a83ab3c 100644
Binary files a/docs/gallery/assets/treasure-chest-hero.webp and b/docs/gallery/assets/treasure-chest-hero.webp differ
diff --git a/docs/gallery/index.html b/docs/gallery/index.html
index 93257e4..3ec19a1 100644
--- a/docs/gallery/index.html
+++ b/docs/gallery/index.html
@@ -953,12 +953,12 @@ <h2><a href="street-lantern/">street-lantern</a></h2>
       </article>
       <article class="card" data-tags="mesh export showcase">
         <a class="card-media" href="treasure-chest/" aria-label="treasure-chest example detail page">
-          <img src="assets/treasure-chest-hero.webp" alt="treasure-chest — A procedural slatted treasure chest through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." loading="lazy" decoding="async" />
+          <img src="assets/treasure-chest-hero.webp" alt="treasure-chest — A procedural iron-bound chest with a lofted barrel-vault lid, U-wrap bands, and hinge knuckles through UVs, bake, LOD, collider, and Unity glTF, asserting…" loading="lazy" decoding="async" />
         </a>
         <div class="card-body">
           <h2><a href="treasure-chest/">treasure-chest</a></h2>
-          <p class="teaches">A procedural slatted treasure chest 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: 5724 tris, two materials with 180 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.776×0.549×0.631 m, LOD ratios in band, convex collider 138 tris, non-empty glTF. --skip-decimate exits 9 on the LOD1 ratio budget.</p>
+          <p class="teaches">A procedural iron-bound chest with a lofted barrel-vault lid, U-wrap bands, and hinge knuckles through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.</p>
+          <p class="witnesses"><span class="tag">witnesses</span> Recomputed: 3852 tris, two materials with 1608 wood and 318 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.764×0.542×0.691 m, LOD ratios in band, convex collider 176 tris, non-empty glTF. Hygiene all zero, four feet at zmin 0, lid-knuckle to hinge barrel 7 mm, band-wall gap 0. --float-hinge exits 17 on the hinge join; --narrow-bands exits 18 on the band seat.</p>
           <a class="card-link" href="treasure-chest/">View example <span aria-hidden="true">&rarr;</span></a>
         </div>
       </article>
@@ -1129,12 +1129,12 @@ <h2><a href="wall-torch/">wall-torch</a></h2>
       </article>
       <article class="card" data-tags="mesh export showcase">
         <a class="card-media" href="tavern-stool/" aria-label="tavern-stool example detail page">
-          <img src="assets/tavern-stool-hero.webp" alt="tavern-stool — A procedural tavern stool with a round seat, turned splayed legs, stretchers, and iron ferrules through UVs, bake, LOD, collider, and Unity glTF, asserting…" loading="lazy" decoding="async" />
+          <img src="assets/tavern-stool-hero.webp" alt="tavern-stool — A procedural tavern stool with a lathed seat, turned splayed legs, tenoned stretchers, and iron ferrule cups through UVs, bake, LOD, collider, and Unity glTF…" loading="lazy" decoding="async" />
         </a>
         <div class="card-body">
           <h2><a href="tavern-stool/">tavern-stool</a></h2>
-          <p class="teaches">A procedural tavern stool with a round seat, turned splayed legs, stretchers, and iron ferrules 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: 5396 tris, two materials with 2542 wood and 40 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.309×0.309×0.467 m, LOD ratios in band, convex collider 96 tris, non-empty glTF. --skip-decimate exits 9 on the LOD1 ratio budget.</p>
+          <p class="teaches">A procedural tavern stool with a lathed seat, turned splayed legs, tenoned stretchers, and iron ferrule cups 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: 2528 tris, two materials with 1168 wood and 256 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.340×0.340×0.470 m, LOD ratios in band, convex collider 396 tris, non-empty glTF. Hygiene all zero, four ferrule cups at zmin 0, stretcher-leg gap 0, ferrule clearance −1.25 mm. --float-stretchers exits 17 on the stretcher join; --pipe-ferrule exits 18 on the ferrule bite band.</p>
           <a class="card-link" href="tavern-stool/">View example <span aria-hidden="true">&rarr;</span></a>
         </div>
       </article>
diff --git a/docs/gallery/tavern-stool/index.html b/docs/gallery/tavern-stool/index.html
index 13a993d..90b0405 100644
--- a/docs/gallery/tavern-stool/index.html
+++ b/docs/gallery/tavern-stool/index.html
@@ -4,18 +4,18 @@
   <meta charset="utf-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1" />
   <title>tavern-stool — Examples — Blender Developer Tools</title>
-  <meta name="description" content="A procedural tavern stool with a round seat, turned splayed legs, stretchers, and iron ferrules through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
+  <meta name="description" content="A procedural tavern stool with a lathed seat, turned splayed legs, tenoned stretchers, and iron ferrule cups 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/tavern-stool/" />
   <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="tavern-stool — Examples — Blender Developer Tools" />
-  <meta property="og:description" content="A procedural tavern stool with a round seat, turned splayed legs, stretchers, and iron ferrules through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
+  <meta property="og:description" content="A procedural tavern stool with a lathed seat, turned splayed legs, tenoned stretchers, and iron ferrule cups 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/tavern-stool/" />
   <meta property="og:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/tavern-stool-hero.webp" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="tavern-stool — Examples — Blender Developer Tools" />
-  <meta name="twitter:description" content="A procedural tavern stool with a round seat, turned splayed legs, stretchers, and iron ferrules through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
+  <meta name="twitter:description" content="A procedural tavern stool with a lathed seat, turned splayed legs, tenoned stretchers, and iron ferrule cups 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/tavern-stool-hero.webp" />
   <style>
     /* fonts are deployed by the landing build (docs/fonts/) */
@@ -246,35 +246,48 @@
   </div>
   <header class="hero">
     <h1>tavern-stool</h1>
-    <p>A procedural tavern stool with a round seat, turned splayed legs, stretchers, and iron ferrules through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.</p>
+    <p>A procedural tavern stool with a lathed seat, turned splayed legs, tenoned stretchers, and iron ferrule cups 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 tavern-stool render">
       <img src="../assets/tavern-stool-hero.webp" alt="tavern-stool 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: 5396 tris, two materials with 2542 wood and 40 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.309×0.309×0.467 m, LOD ratios in band, convex collider 96 tris, non-empty glTF. --skip-decimate exits 9 on the LOD1 ratio budget.</div>
+    <div class="callout"><span class="tag">witnesses</span> Recomputed: 2528 tris, two materials with 1168 wood and 256 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.340×0.340×0.470 m, LOD ratios in band, convex collider 396 tris, non-empty glTF. Hygiene all zero, four ferrule cups at zmin 0, stretcher-leg gap 0, ferrule clearance −1.25 mm. --float-stretchers exits 17 on the stretcher join; --pipe-ferrule exits 18 on the ferrule bite band.</div>
     <div class="runline">
       <pre id="runCmd">blender --background --python showcase/tavern-stool/tavern_stool.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 tavern stool (round seat, turned splayed legs, stretchers, iron ferrules) 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 tavern stool (lathed round seat, turned splayed legs, tenoned stretchers, iron ferrule cups) then the shipped pipeline: unique-cell UVs, Cycles high-to-low normal bake, LOD chain, convex collider, Unity glTF export.</p>
+<p>Legs are one loft per leg, not stacked cones. Ferrules are vertical cups the foot drops into; wood ends above the cup so a splayed cone does not sawtooth through the wall. Stretchers are classified as compact rails, not the seat disc.</p>
 <p>It asserts <strong>budget conformance</strong> of the generated result. It does not witness an API contract. &quot;It rendered without error&quot; is not a check.</p>
 <p><strong>Composes</strong> skills <code>mesh-editing-and-bmesh</code>, <code>bake-high-to-low</code>, <code>depsgraph-and-evaluated-data</code>, <code>engine-export-presets</code>, and snippets <code>bake_normal_high_to_low.py</code>, <code>setup_bake_target_image.py</code>, <code>lod_chain.py</code> / <code>decimate_to_budget.py</code>, <code>convex_hull_collider.py</code>, <code>export_preset_unity.py</code> (helpers copied, not imported as a package).</p>
 <h2>Budgets</h2>
 <p>Declared as named constants; every gate <strong>recomputes</strong> from the mesh, materials, UVs, evaluated LOD, collider, or export file.</p>
-<p>| Axis | Declared | Measured (4.5.11 / 5.1.2 / 5.2.1) | | --- | --- | --- | | Base triangles | 5250–5550 | 5396 / 5396 / 5396 | | LOD1 ratio | 0.32–0.62 of base | 0.5000 / 0.5000 / 0.5000 | | LOD2 ratio | 0.10–0.35 of base | 0.2198 / 0.2198 / 0.2198 | | Materials | exactly 2 distinct, ≥24 wood, ≥16 metal | 2 slots, 2542 wood, 40 metal | | UVs | in <code>0..1</code>, AABB overlap ≤ 1e-5 | in range, overlap 0 | | Outer AABB | (0.309, 0.309, 0.467) m ± 0.01 | (0.3093, 0.3093, 0.4670), zmin 0.002 | | Collider tris | ≤ 140 | 96 | | Export | written, size &gt; 0 | 380604 / 380604 / 380588 bytes |</p>
-<p>DECIMATE COLLAPSE triangle counts are <strong>not</strong> identical across series in general — the gate is a ratio band, not an exact count. On this mesh LOD2 matched across 4.5.11 / 5.1.2 / 5.2.1. Bake pixels are stochastic; the gate is <code>has_data</code> plus operator <code>FINISHED</code>, not byte-identity. Construction uses no RNG. Export byte counts differ by 16 B on 5.2.1 (glTF serializer), not a gated axis.</p>
-<p><code>--skip-decimate</code> skips the LOD DECIMATE stage so LOD1 ratio is 1.0 and exit 9 fires. That is the named budget the falsifier violates.</p>
+<p>| Axis | Declared | Measured (4.5.11 / 5.1.2 / 5.2.1) | | --- | --- | --- | | Base triangles | 2300–3200 | 2528 / 2528 / 2528 | | LOD1 ratio | 0.32–0.62 of base | 0.5000 / 0.5000 / 0.5000 | | LOD2 ratio | 0.10–0.35 of base | 0.2199 / 0.2199 / 0.2199 | | Materials | exactly 2 distinct; ≥200 wood, ≥48 metal faces | 2 slots; 1168 / 256 | | UVs | in <code>0..1</code>, AABB overlap ≤ 1e-5 | in range, overlap 0 | | Outer AABB | (0.341, 0.341, 0.470) m ± 0.015 | (0.3400, 0.3400, 0.4700), zmin 0 | | Collider tris | ≤ 640 | 396 | | Export | written, size &gt; 0 | 215912 / 215912 / 215900 bytes |</p>
+<h3>Hygiene</h3>
+<p>Recomputed from the generated mesh, not asserted about the script.</p>
+<p>| Axis | Declared | Measured (all three) | | --- | --- | --- | | Non-manifold edges | 0 | 0 | | Loose verts / edges | 0 / 0 | 0 / 0 | | Doubles merged at 1e-5 | 0 | 0 | | Zero-area faces | 0 | 0 | | N-gons | 0 | 0 | | Coplanar disjoint face pairs | 0 | 0 | | Grounded: <code>zmin</code> | within 1e-4 of 0 | 0.0000 | | Named supports: 4 ferrule cups | each <code>zmin</code> ≤ 1e-3 | 4, cup_z 0.00000 | | Seat | 0.340 m dia × 0.470 m high ± 0.02 | 0.3400 × 0.4700 |</p>
+<h3>Joint fit and seat</h3>
+<p>| Axis | Declared | Measured (all three) | | --- | --- | --- | | Stretcher-leg BVH gap | ≤ 0.008 m | 0.00000 | | Ferrule inner clearance (<code>r_wood − r_in</code>) | −0.005 .. 0.000 m | −0.00125 |</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 may differ by a few bytes across series.</p>
+<h3>Falsifiers</h3>
+<p>Each violates one named budget. All seven were run on 4.5.11, 5.1.2 and 5.2.1 and returned the same code on each.</p>
+<p>| Flag | Budget violated | Exit | | --- | --- | --- | | <code>--skip-decimate</code> | LOD1 ratio band | 9 | | <code>--stray-vert</code> | loose vertex count is 0 | 15 | | <code>--lift-z</code> | bounding box <code>zmin</code> is 0 | 16 | | <code>--short-legs</code> | named ferrule cups at Z=0 | 16 | | <code>--float-stretchers</code> | stretcher-leg join | 17 | | <code>--pipe-ferrule</code> | ferrule inner-clearance band | 18 |</p>
 <h2>Run</h2>
 <pre><code>blender --background --python tavern_stool.py --
 blender --background --python tavern_stool.py -- --skip-decimate
+blender --background --python tavern_stool.py -- --stray-vert
+blender --background --python tavern_stool.py -- --lift-z
+blender --background --python tavern_stool.py -- --short-legs
+blender --background --python tavern_stool.py -- --float-stretchers
+blender --background --python tavern_stool.py -- --pipe-ferrule
 blender --background --python tavern_stool.py -- --output stool.png</code></pre>
-<p>Smoke does not pass <code>--output</code> or <code>--skip-decimate</code>.</p>
+<p>Smoke passes no flags.</p>
 <h2>Exit codes</h2>
-<p>File-local. <code>9</code> is a valid check code. <code>10</code> is reserved for <code>gallery_framing.check_framing</code> on the <code>--output</code> path.</p>
-<p>| Code | Meaning | | --- | --- | | 0 | Success | | 1 | Uncaught exception (FATAL wrapper) | | 2 | argparse / usage | | 3 | Mesh did not build / no UV layer | | 4 | Base triangle count outside range | | 5 | Material count ≠ 2 distinct slots, or wood/metal faces missing | | 6 | UVs outside 0..1 | | 7 | UV AABB overlap above tolerance | | 8 | World AABB off declared outer size | | 9 | LOD ratio band (<code>--skip-decimate</code> lands here) | | 10 | Framing gate (render path only) | | 11 | Collider triangle count above ceiling | | 12 | Bake did not finish or image has no data | | 13 | Export file missing or empty | | 14 | <code>--output</code> produced no file |</p>
+<p>File-local. <code>9</code> is a valid check code. <code>10</code> is reserved for <code>gallery_framing.check_framing</code> on the <code>--output</code> path. <code>15</code>–<code>19</code> are the hygiene and joint-fit family.</p>
+<p>| Code | Meaning | | --- | --- | | 0 | Success | | 1 | Uncaught exception (FATAL wrapper) | | 2 | argparse / usage | | 3 | Mesh did not build / no UV layer | | 4 | Base triangle count outside range | | 5 | Material count ≠ 2 distinct slots, or a face-count floor missed | | 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: loose, non-manifold, zero-area, doubles, n-gons, z-fight | | 16 | Not grounded: bounding box <code>zmin</code> off 0, or a named ferrule cup floats | | 17 | Joint fit: stretcher-leg gap | | 18 | Seat: ferrule inner-clearance band | | 19 | Seat diameter or height off the stated real-world size |</p>
     </section>
     <section class="detail-section src">
       <h2>Source</h2>
@@ -289,8 +302,11 @@ <h2>Source</h2>
 normal bake, LOD chain, convex collider, Unity glTF export.
 
 Budgets are declared below and recomputed from the generated result.
-They are not API-contract witnesses. ``--skip-decimate`` skips the LOD
-DECIMATE stage so the LOD-ratio budget fails.
+They are not API-contract witnesses. Each falsifier violates one named
+budget: ``--skip-decimate`` the LOD-ratio band, ``--stray-vert`` mesh
+hygiene, ``--lift-z`` grounded zmin, ``--short-legs`` named ferrule
+supports, ``--float-stretchers`` stretcher joint-fit, ``--pipe-ferrule``
+ferrule-cup seat.
 
 No RNG. Construction is closed-form. DECIMATE COLLAPSE triangle counts
 are not byte-identical across Blender versions — the LOD gate is a
@@ -309,11 +325,9 @@ <h2>Source</h2>
 
 <span class="k">import</span> bmesh
 <span class="k">import</span> bpy
-<span class="k">from</span> mathutils <span class="k">import</span> Euler, Vector
+<span class="k">from</span> mathutils <span class="k">import</span> Vector
+<span class="k">from</span> mathutils.bvhtree <span class="k">import</span> BVHTree
 
-<span class="c"># Showcase lives at repo-root/showcase/, not under examples/. The framing</span>
-<span class="c"># helper is the repo&#x27;s only shared import and lives next to the examples;</span>
-<span class="c"># resolve the repo root so we do not move gallery_framing.py.</span>
 _REPO = os.path.abspath(
     os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir, os.pardir)
 )
@@ -321,19 +335,35 @@ <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>
 
-SEAT_R = <span class="n">0.155</span>
-SEAT_T = <span class="n">0.042</span>
-SEAT_Z = <span class="n">0.46</span>
+<span class="c"># A short tavern stool: ~34 cm seat, 47 cm to the rim, legs splayed so</span>
+<span class="c"># the feet land near the seat&#x27;s shadow. The old piece was a 16-gon puck</span>
+<span class="c"># on four stacked cones clustered under the disc.</span>
+SEAT_R = <span class="n">0.170</span>
+SEAT_T = <span class="n">0.040</span>
+SEAT_Z = <span class="n">0.470</span>
+SEAT_SEGS = <span class="n">48</span>
 N_LEGS = <span class="n">4</span>
-LEG_TOP_R = <span class="n">0.078</span>
-LEG_BOT_R = <span class="n">0.125</span>
-STRETCH_Z = <span class="n">0.175</span>
-BBOX_TOL = <span class="n">0.01</span>
+LEG_TOP_R = <span class="n">0.128</span>
+LEG_BOT_R = <span class="n">0.202</span>
+LEG_SEGS = <span class="n">16</span>
+FERRULE_H = <span class="n">0.022</span>
+FERRULE_T = <span class="n">0.0045</span>
+FERRULE_SEGS = <span class="n">16</span>
+STRETCH_T = <span class="n">0.58</span>
+STRETCH_R = <span class="n">0.011</span>
+STRETCH_SEGS = <span class="n">12</span>
+STRETCH_TENON = <span class="n">0.012</span>
+SEAT_TENON = <span class="n">0.018</span>
+BBOX_TOL = <span class="n">0.015</span>
+BODY_DIA = <span class="n">2.0</span> * SEAT_R
+BODY_DIA_TOL = <span class="n">0.02</span>
+BODY_H = SEAT_Z
+BODY_H_TOL = <span class="n">0.02</span>
 <span class="c"># Fitted after locking geometry. Recomputed from bound_box.</span>
-OUTER_SIZE = (<span class="n">0.309</span>, <span class="n">0.309</span>, <span class="n">0.467</span>)
+OUTER_SIZE = (<span class="n">0.341</span>, <span class="n">0.341</span>, <span class="n">0.470</span>)
 
-BASE_TRIS_MIN = <span class="n">5250</span>
-BASE_TRIS_MAX = <span class="n">5550</span>
+BASE_TRIS_MIN = <span class="n">2300</span>
+BASE_TRIS_MAX = <span class="n">3200</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>
@@ -343,15 +373,52 @@ <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">140</span>
+COLLIDER_TRIS_MAX = <span class="n">640</span>
 BAKE_RES = <span class="n">256</span>
 CAGE_EXTRUSION = <span class="n">0.06</span>
-METAL_FACES_MIN = <span class="n">16</span>
-WOOD_FACES_MIN = <span class="n">24</span>
+METAL_FACES_MIN = <span class="n">48</span>
+WOOD_FACES_MIN = <span class="n">200</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">1e-4</span>
+ZFIGHT_COS = <span class="n">0.999</span>
+LIFT_Z = <span class="n">0.05</span>
+FERRULE_Z_MAX = <span class="n">1e-3</span>
+STRETCH_JOIN = <span class="n">0.008</span>
+FERRULE_BITE_MIN = -<span class="n">0.005</span>
+FERRULE_BITE_MAX = <span class="n">0.000</span>
 
 WOOD_IDX = <span class="n">0</span>
 METAL_IDX = <span class="n">1</span>
 
+<span class="c"># Turned-leg profile: (t along the axis from seat tenon to ferrule, radius).</span>
+<span class="c"># One loft, not four stacked cones. t=0 is up in the seat.</span>
+LEG_PROFILE = (
+    (<span class="n">0.00</span>, <span class="n">0.018</span>),
+    (<span class="n">0.08</span>, <span class="n">0.022</span>),
+    (<span class="n">0.20</span>, <span class="n">0.025</span>),
+    (<span class="n">0.36</span>, <span class="n">0.016</span>),
+    (<span class="n">0.52</span>, <span class="n">0.015</span>),
+    (<span class="n">0.60</span>, <span class="n">0.018</span>),
+    (<span class="n">0.78</span>, <span class="n">0.016</span>),
+    (<span class="n">0.92</span>, <span class="n">0.018</span>),
+    (<span class="n">1.00</span>, <span class="n">0.017</span>),
+)
+
+<span class="c"># Seat, underside to dish. One lathe, not three stacked cylinders.</span>
+<span class="c"># (z above the underside, radius). r=0 is the dish centre.</span>
+SEAT_PROFILE = (
+    (<span class="n">0.000</span>, <span class="n">0.122</span>),
+    (<span class="n">0.010</span>, <span class="n">0.138</span>),
+    (<span class="n">0.016</span>, <span class="n">0.158</span>),
+    (<span class="n">0.022</span>, <span class="n">0.168</span>),
+    (<span class="n">0.032</span>, <span class="n">0.170</span>),
+    (<span class="n">0.040</span>, <span class="n">0.164</span>),
+    (<span class="n">0.037</span>, <span class="n">0.095</span>),
+    (<span class="n">0.034</span>, <span class="n">0.000</span>),
+)
+
 
 <span class="k">def</span> eevee_engine_id():
     <span class="k">return</span> <span class="s">&quot;BLENDER_EEVEE&quot;</span> <span class="k">if</span> bpy.app.version &gt;= (<span class="n">5</span>, <span class="n">0</span>, <span class="n">0</span>) <span class="k">else</span> <span class="s">&quot;BLENDER_EEVEE_NEXT&quot;</span>
@@ -368,7 +435,6 @@ <h2>Source</h2>
 
 
 <span class="k">def</span> evaluated_triangle_count(obj):
-    <span class="c"># Duplicated from snippets/lod_chain.py / decimate_to_budget.py (not a package).</span>
     depsgraph = bpy.context.evaluated_depsgraph_get()
     eval_obj = obj.evaluated_get(depsgraph)
     eval_mesh = eval_obj.to_mesh()
@@ -379,92 +445,144 @@ <h2>Source</h2>
         eval_obj.to_mesh_clear()
 
 
-<span class="k">def</span> add_box(bm, loc, scale, mat_idx, euler=(<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>)):
-    geo = bmesh.ops.create_cube(bm, size=<span class="n">1.0</span>)
-    verts = geo[<span class="s">&quot;verts&quot;</span>]
-    rot = Euler(euler).to_matrix()
-    origin = Vector(loc)
-    <span class="k">for</span> v <span class="k">in</span> verts:
-        p = Vector((v.co.x * scale[<span class="n">0</span>], v.co.y * scale[<span class="n">1</span>], v.co.z * scale[<span class="n">2</span>]))
-        v.co = rot @ p + origin
-    faces = {f <span class="k">for</span> v <span class="k">in</span> verts <span class="k">for</span> f <span class="k">in</span> v.link_faces}
-    <span class="k">for</span> f <span class="k">in</span> faces:
-        f.material_index = mat_idx
+<span class="k">def</span> _bridge_rings(bm, a, b, mat_idx):
+    <span class="k">if</span> len(a) == <span class="n">1</span> <span class="k">and</span> len(b) &gt; <span class="n">1</span>:
+        c = a[<span class="n">0</span>]
+        <span class="k">for</span> k <span class="k">in</span> range(len(b)):
+            kn = (k + <span class="n">1</span>) % len(b)
+            face = bm.faces.new((c, b[k], b[kn]))
+            face.material_index = mat_idx
+    <span class="k">elif</span> len(b) == <span class="n">1</span> <span class="k">and</span> len(a) &gt; <span class="n">1</span>:
+        c = b[<span class="n">0</span>]
+        <span class="k">for</span> k <span class="k">in</span> range(len(a)):
+            kn = (k + <span class="n">1</span>) % len(a)
+            face = bm.faces.new((c, a[kn], a[k]))
+            face.material_index = mat_idx
+    <span class="k">else</span>:
+        segs = len(a)
+        <span class="k">for</span> k <span class="k">in</span> range(segs):
+            kn = (k + <span class="n">1</span>) % segs
+            face = bm.faces.new((a[k], a[kn], b[kn], b[k]))
+            face.material_index = mat_idx
+
+
+<span class="k">def</span> loft_rings(bm, rings, mat_idx, cap_start=<span class="k">True</span>, cap_end=<span class="k">True</span>, cyclic=<span class="k">False</span>):
+    <span class="s">&quot;&quot;&quot;Loft a stack of rings. A ring of one vert is a centre cap.&quot;&quot;&quot;</span>
+    verts = [v <span class="k">for</span> ring <span class="k">in</span> rings <span class="k">for</span> v <span class="k">in</span> ring]
+    n = len(rings)
+    <span class="k">for</span> i <span class="k">in</span> range(n - <span class="n">1</span>):
+        _bridge_rings(bm, rings[i], rings[i + <span class="n">1</span>], mat_idx)
+    <span class="k">if</span> cyclic <span class="k">and</span> n &gt; <span class="n">2</span>:
+        _bridge_rings(bm, rings[-<span class="n">1</span>], rings[<span class="n">0</span>], mat_idx)
+    <span class="k">if</span> cap_start <span class="k">and</span> len(rings[<span class="n">0</span>]) &gt; <span class="n">1</span>:
+        ring = rings[<span class="n">0</span>]
+        c = bm.verts.new(sum((v.co <span class="k">for</span> v <span class="k">in</span> ring), Vector((<span class="n">0</span>, <span class="n">0</span>, <span class="n">0</span>))) / len(ring))
+        verts.append(c)
+        <span class="k">for</span> k <span class="k">in</span> range(len(ring)):
+            kn = (k + <span class="n">1</span>) % len(ring)
+            face = bm.faces.new((c, ring[kn], ring[k]))
+            face.material_index = mat_idx
+    <span class="k">if</span> cap_end <span class="k">and</span> len(rings[-<span class="n">1</span>]) &gt; <span class="n">1</span>:
+        ring = rings[-<span class="n">1</span>]
+        c = bm.verts.new(sum((v.co <span class="k">for</span> v <span class="k">in</span> ring), Vector((<span class="n">0</span>, <span class="n">0</span>, <span class="n">0</span>))) / len(ring))
+        verts.append(c)
+        <span class="k">for</span> k <span class="k">in</span> range(len(ring)):
+            kn = (k + <span class="n">1</span>) % len(ring)
+            face = bm.faces.new((c, ring[k], ring[kn]))
+            face.material_index = mat_idx
     <span class="k">return</span> verts
 
 
-<span class="k">def</span> add_oriented_box(bm, a, b, scale_xy, mat_idx):
-    a = Vector(a)
-    b = Vector(b)
-    delta = b - a
-    length = delta.length
-    <span class="k">if</span> length &lt; <span class="n">1e-8</span>:
-        <span class="k">return</span> []
-    quat = Vector((<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">1.0</span>)).rotation_difference(delta.normalized())
-    eul = quat.to_euler(<span class="s">&quot;XYZ&quot;</span>)
-    <span class="k">return</span> add_box(
-        bm,
-        ((a + b) * <span class="n">0.5</span>),
-        (scale_xy[<span class="n">0</span>], scale_xy[<span class="n">1</span>], length),
-        mat_idx,
-        euler=(eul.x, eul.y, eul.z),
-    )
+<span class="k">def</span> lathe_z(bm, profile, segs, mat_idx, z0=<span class="n">0.0</span>):
+    rings = []
+    <span class="k">for</span> z, r <span class="k">in</span> profile:
+        <span class="k">if</span> r &lt;= <span class="n">1e-8</span>:
+            rings.append([bm.verts.new((<span class="n">0.0</span>, <span class="n">0.0</span>, z0 + z))])
+            <span class="k">continue</span>
+        ring = []
+        <span class="k">for</span> i <span class="k">in</span> range(segs):
+            a = <span class="n">2.0</span> * math.pi * i / segs
+            ring.append(
+                bm.verts.new((r * math.cos(a), r * math.sin(a), z0 + z))
+            )
+        rings.append(ring)
+    <span class="c"># Profile already ends at r=0 (dish) or a ring. No extra caps.</span>
+    cap_start = len(rings[<span class="n">0</span>]) &gt; <span class="n">1</span>
+    cap_end = len(rings[-<span class="n">1</span>]) &gt; <span class="n">1</span>
+    <span class="k">return</span> loft_rings(bm, rings, mat_idx, cap_start=cap_start, cap_end=cap_end)
 
 
-<span class="k">def</span> add_cone_between(bm, a, b, r1, r2, segments, mat_idx):
+<span class="k">def</span> lathe_axis(bm, a, b, profile, segs, mat_idx, cap_start=<span class="k">True</span>, cap_end=<span class="k">True</span>):
     a = Vector(a)
     b = Vector(b)
     delta = b - a
     length = delta.length
     <span class="k">if</span> length &lt; <span class="n">1e-8</span>:
         <span class="k">return</span> []
-    quat = Vector((<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">1.0</span>)).rotation_difference(delta.normalized())
-    eul = quat.to_euler(<span class="s">&quot;XYZ&quot;</span>)
-    <span class="k">return</span> add_cone(
-        bm, (a + b) * <span class="n">0.5</span>, r1, r2, length, segments, mat_idx,
-        euler=(eul.x, eul.y, eul.z),
+    tangent = delta.normalized()
+    side = Vector((-tangent.y, tangent.x, <span class="n">0.0</span>))
+    <span class="k">if</span> side.length &lt; <span class="n">1e-6</span>:
+        side = Vector((<span class="n">1.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>))
+    <span class="k">else</span>:
+        side.normalize()
+    up = tangent.cross(side).normalized()
+    rings = []
+    <span class="k">for</span> t, radius <span class="k">in</span> profile:
+        p = a + tangent * (t * length)
+        <span class="k">if</span> radius &lt;= <span class="n">1e-8</span>:
+            rings.append([bm.verts.new(p)])
+            <span class="k">continue</span>
+        ring = []
+        <span class="k">for</span> i <span class="k">in</span> range(segs):
+            ang = <span class="n">2.0</span> * math.pi * i / segs
+            ring.append(
+                bm.verts.new(p + side * (radius * math.cos(ang)) + up * (radius * math.sin(ang)))
+            )
+        rings.append(ring)
+    <span class="k">return</span> loft_rings(
+        bm, rings, mat_idx, cap_start=cap_start, cap_end=cap_end,
     )
 
 
-<span class="k">def</span> add_cone(bm, loc, radius1, radius2, depth, segments, mat_idx, euler=(<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>)):
-    geo = bmesh.ops.create_cone(
-        bm,
-        cap_ends=<span class="k">True</span>,
-        cap_tris=<span class="k">False</span>,
-        segments=segments,
-        radius1=radius1,
-        radius2=radius2,
-        depth=depth,
+<span class="k">def</span> add_cup(bm, xy, z0, z1, r_in, r_out, segs, mat_idx):
+    <span class="s">&quot;&quot;&quot;Vertical ferrule cup: annulus walls, open on the top, planted at z0.&quot;&quot;&quot;</span>
+    cx, cy = xy
+    specs = (
+        (z0, r_in),
+        (z0, r_out),
+        (z1, r_out),
+        (z1, r_in),
+    )
+    rings = []
+    <span class="k">for</span> z, r <span class="k">in</span> specs:
+        ring = []
+        <span class="k">for</span> i <span class="k">in</span> range(segs):
+            a = <span class="n">2.0</span> * math.pi * i / segs
+            ring.append(
+                bm.verts.new((cx + r * math.cos(a), cy + r * math.sin(a), z))
+            )
+        rings.append(ring)
+    <span class="k">return</span> loft_rings(
+        bm, rings, mat_idx, cap_start=<span class="k">False</span>, cap_end=<span class="k">False</span>, cyclic=<span class="k">True</span>,
     )
-    verts = list(geo[<span class="s">&quot;verts&quot;</span>])
-    rot = Euler(euler).to_matrix()
-    origin = Vector(loc)
-    <span class="k">for</span> v <span class="k">in</span> verts:
-        v.co = rot @ v.co + origin
-    faces = {f <span class="k">for</span> v <span class="k">in</span> verts <span class="k">for</span> f <span class="k">in</span> v.link_faces}
-    <span class="k">for</span> f <span class="k">in</span> faces:
-        f.material_index = mat_idx
-    <span class="k">return</span> verts
-
-
-<span class="k">def</span> add_cylinder(bm, loc, radius, depth, segments, mat_idx, euler=(<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>)):
-    <span class="k">return</span> add_cone(bm, loc, radius, radius, depth, segments, mat_idx, euler=euler)
 
 
-<span class="k">def</span> add_rim(bm, loc, major, minor, mat_idx, euler=(<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>)):
-    n_major = <span class="n">12</span>
-    n_minor = <span class="n">6</span>
+<span class="k">def</span> add_pipe_torus(bm, xy, z, major, minor, mat_idx):
+    <span class="s">&quot;&quot;&quot;Falsifier: a metal torus planted at z that does not cup the foot.&quot;&quot;&quot;</span>
+    n_major, n_minor = <span class="n">12</span>, <span class="n">4</span>
+    cx, cy = xy
     rings = []
     <span class="k">for</span> i <span class="k">in</span> range(n_major):
         u = i * (<span class="n">2.0</span> * math.pi / n_major)
         ring = []
         <span class="k">for</span> j <span class="k">in</span> range(n_minor):
             v = j * (<span class="n">2.0</span> * math.pi / n_minor)
-            x = (major + minor * math.cos(v)) * math.cos(u)
-            y = (major + minor * math.cos(v)) * math.sin(u)
-            z = minor * math.sin(v)
-            ring.append(bm.verts.new((x, y, z)))
+            px = cx + (major + minor * math.cos(v)) * math.cos(u)
+            py = cy + (major + minor * math.cos(v)) * math.sin(u)
+            pz = z + minor * (<span class="n">1.0</span> + math.sin(v))
+            ring.append(bm.verts.new((px, py, pz)))
         rings.append(ring)
+    verts = [v <span class="k">for</span> ring <span class="k">in</span> rings <span class="k">for</span> v <span class="k">in</span> ring]
     <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):
@@ -473,11 +591,6 @@ <h2>Source</h2>
                 (rings[i][j], rings[i2][j], rings[i2][j2], rings[i][j2])
             )
             face.material_index = mat_idx
-    verts = [v <span class="k">for</span> ring <span class="k">in</span> rings <span class="k">for</span> v <span class="k">in</span> ring]
-    rot = Euler(euler).to_matrix()
-    origin = Vector(loc)
-    <span class="k">for</span> v <span class="k">in</span> verts:
-        v.co = rot @ v.co + origin
     <span class="k">return</span> verts
 
 
@@ -497,9 +610,7 @@ <h2>Source</h2>
         col = i % cols
         row = i // cols
         nrm = face.normal
-        ax = abs(nrm.x)
-        ay = abs(nrm.y)
-        az = abs(nrm.z)
+        ax, ay, az = abs(nrm.x), abs(nrm.y), abs(nrm.z)
         coords = []
         <span class="k">for</span> loop <span class="k">in</span> face.loops:
             co = loop.vert.co
@@ -524,86 +635,108 @@ <h2>Source</h2>
             )
 
 
-<span class="k">def</span> build_stool_mesh(name, bevel_offset, bevel_segments):
+<span class="k">def</span> _leg_ends(i):
+    ang = math.pi / <span class="n">4.0</span> + i * (math.pi * <span class="n">2.0</span> / N_LEGS)
+    c, s = math.cos(ang), math.sin(ang)
+    seat_under = SEAT_Z - SEAT_T
+    top = Vector((LEG_TOP_R * c, LEG_TOP_R * s, seat_under + SEAT_TENON))
+    bot = Vector((LEG_BOT_R * c, LEG_BOT_R * s, FERRULE_H + <span class="n">0.003</span>))
+    foot_xy = (LEG_BOT_R * c, LEG_BOT_R * s)
+    <span class="k">return</span> top, bot, foot_xy, ang
+
+
+<span class="k">def</span> build_stool_mesh(
+    name,
+    short_legs=<span class="k">False</span>,
+    float_stretchers=<span class="k">False</span>,
+    pipe_ferrule=<span class="k">False</span>,
+):
     bm = bmesh.new()
-    wood_verts = []
-    metal_faces = set()
     <span class="k">try</span>:
-        seat_center = (<span class="n">0.0</span>, <span class="n">0.0</span>, SEAT_Z - SEAT_T / <span class="n">2.0</span>)
-        wood_verts.extend(add_cylinder(bm, seat_center, SEAT_R, SEAT_T, <span class="n">16</span>, WOOD_IDX))
-        wood_verts.extend(
-            add_cylinder(
-                bm,
-                (<span class="n">0.0</span>, <span class="n">0.0</span>, SEAT_Z - SEAT_T - <span class="n">0.012</span>),
-                SEAT_R - <span class="n">0.018</span>,
-                <span class="n">0.022</span>,
-                <span class="n">16</span>,
-                WOOD_IDX,
-            )
-        )
-        wood_verts.extend(
-            add_cone(
-                bm,
-                (<span class="n">0.0</span>, <span class="n">0.0</span>, SEAT_Z + <span class="n">0.004</span>),
-                SEAT_R - <span class="n">0.012</span>,
-                SEAT_R,
-                <span class="n">0.010</span>,
-                <span class="n">16</span>,
-                WOOD_IDX,
-            )
-        )
+        wood_faces = []
+        metal_faces = []
+        before = set(bm.faces)
+        lathe_z(bm, SEAT_PROFILE, SEAT_SEGS, WOOD_IDX, z0=SEAT_Z - SEAT_T)
+        wood_faces.extend(set(bm.faces) - before)
+
+        ferrule_z0 = <span class="n">0.05</span> <span class="k">if</span> short_legs <span class="k">else</span> <span class="n">0.0</span>
+        <span class="k">if</span> short_legs:
+            before = set(bm.faces)
+            geo = bmesh.ops.create_cube(bm, size=<span class="n">1.0</span>)
+            <span class="k">for</span> v <span class="k">in</span> geo[<span class="s">&quot;verts&quot;</span>]:
+                v.co.x *= <span class="n">0.024</span>
+                v.co.y *= <span class="n">0.024</span>
+                v.co.z *= <span class="n">0.006</span>
+                v.co.z += <span class="n">0.003</span>
+            metal_faces.extend(set(bm.faces) - before)
 
         leg_pts = []
         <span class="k">for</span> i <span class="k">in</span> range(N_LEGS):
-            ang = math.pi / <span class="n">4.0</span> + i * (math.pi * <span class="n">2.0</span> / N_LEGS)
-            c, s = math.cos(ang), math.sin(ang)
-            top = Vector((LEG_TOP_R * c, LEG_TOP_R * s, SEAT_Z - SEAT_T - <span class="n">0.004</span>))
-            bot = Vector((LEG_BOT_R * c, LEG_BOT_R * s, <span class="n">0.012</span>))
-            leg_pts.append((top, bot, ang))
-            d = bot - top
-            p_knuckle = top + d * <span class="n">0.22</span>
-            p_ring = top + d * <span class="n">0.55</span>
-            p_foot = top + d * <span class="n">0.88</span>
-            wood_verts.extend(add_cone_between(bm, top, p_knuckle, <span class="n">0.016</span>, <span class="n">0.024</span>, <span class="n">8</span>, WOOD_IDX))
-            wood_verts.extend(add_cone_between(bm, p_knuckle, p_ring, <span class="n">0.018</span>, <span class="n">0.015</span>, <span class="n">8</span>, WOOD_IDX))
-            wood_verts.extend(add_cone_between(bm, p_ring, p_foot, <span class="n">0.022</span>, <span class="n">0.018</span>, <span class="n">8</span>, WOOD_IDX))
-            wood_verts.extend(add_cone_between(bm, p_foot, bot, <span class="n">0.018</span>, <span class="n">0.028</span>, <span class="n">8</span>, WOOD_IDX))
+            top, bot, foot_xy, ang = _leg_ends(i)
+            leg_pts.append((top, bot, foot_xy, ang))
             before = set(bm.faces)
-            add_cone_between(bm, bot + Vector((<span class="n">0</span>, <span class="n">0</span>, <span class="n">0.006</span>)), bot - Vector((<span class="n">0</span>, <span class="n">0</span>, <span class="n">0.010</span>)), <span class="n">0.030</span>, <span class="n">0.030</span>, <span class="n">8</span>, METAL_IDX)
-            metal_faces.update(set(bm.faces) - before)
+            lathe_axis(bm, top, bot, LEG_PROFILE, LEG_SEGS, WOOD_IDX)
+            wood_faces.extend(set(bm.faces) - before)
 
-        <span class="k">for</span> i <span class="k">in</span> range(N_LEGS):
-            a_top, a_bot, _ = leg_pts[i]
-            b_top, b_bot, _ = leg_pts[(i + <span class="n">1</span>) % N_LEGS]
-            a = a_top.lerp(a_bot, <span class="n">0.62</span>)
-            b = b_top.lerp(b_bot, <span class="n">0.62</span>)
-            wood_verts.extend(add_oriented_box(bm, a, b, (<span class="n">0.022</span>, <span class="n">0.018</span>), WOOD_IDX))
-
-        <span class="k">if</span> bevel_offset &gt; <span class="n">0.0</span>:
-            edges = list({e <span class="k">for</span> v <span class="k">in</span> wood_verts <span class="k">for</span> e <span class="k">in</span> v.link_edges <span class="k">if</span> v.is_valid})
-            <span class="k">if</span> edges:
-                bmesh.ops.bevel(
+            r_foot = LEG_PROFILE[-<span class="n">1</span>][<span class="n">1</span>]
+            r_in = r_foot + <span class="n">0.001</span>
+            r_out = r_in + FERRULE_T
+            before = set(bm.faces)
+            <span class="k">if</span> pipe_ferrule:
+                add_pipe_torus(
+                    bm, foot_xy, ferrule_z0, <span class="n">0.016</span>, <span class="n">0.006</span>, METAL_IDX,
+                )
+            <span class="k">else</span>:
+                add_cup(
                     bm,
-                    geom=edges,
-                    offset=bevel_offset,
-                    segments=bevel_segments,
-                    profile=<span class="n">0.5</span>,
-                    affect=<span class="s">&quot;EDGES&quot;</span>,
-                    clamp_overlap=<span class="k">True</span>,
+                    foot_xy,
+                    ferrule_z0,
+                    ferrule_z0 + FERRULE_H,
+                    r_in,
+                    r_out,
+                    FERRULE_SEGS,
+                    METAL_IDX,
+                )
+            metal_faces.extend(set(bm.faces) - before)
+
+        <span class="k">if</span> <span class="k">not</span> float_stretchers:
+            <span class="k">for</span> i <span class="k">in</span> range(N_LEGS):
+                a_top, a_bot, _, _ = leg_pts[i]
+                b_top, b_bot, _, _ = leg_pts[(i + <span class="n">1</span>) % N_LEGS]
+                a = a_top.lerp(a_bot, STRETCH_T)
+                b = b_top.lerp(b_bot, STRETCH_T)
+                d = (b - a).normalized()
+                r_leg = <span class="n">0.0</span>
+                <span class="k">for</span> t, r <span class="k">in</span> LEG_PROFILE:
+                    <span class="k">if</span> t &gt;= STRETCH_T:
+                        r_leg = r
+                        <span class="k">break</span>
+                a_end = a + d * (r_leg - STRETCH_TENON)
+                b_end = b - d * (r_leg - STRETCH_TENON)
+                before = set(bm.faces)
+                lathe_axis(
+                    bm, a_end, b_end,
+                    ((<span class="n">0.0</span>, STRETCH_R), (<span class="n">1.0</span>, STRETCH_R)),
+                    STRETCH_SEGS, WOOD_IDX,
                 )
+                wood_faces.extend(set(bm.faces) - before)
 
         pack_uvs(bm)
         bmesh.ops.recalc_face_normals(bm, faces=list(bm.faces))
+        wood_set = set(wood_faces)
+        metal_set = set(metal_faces)
         <span class="k">for</span> face <span class="k">in</span> bm.faces:
-            face.smooth = <span class="k">True</span>
+            <span class="k">if</span> face <span class="k">in</span> metal_set:
+                face.material_index = METAL_IDX
+                face.smooth = <span class="k">True</span>
+            <span class="k">else</span>:
+                face.material_index = WOOD_IDX
+                face.smooth = <span class="k">True</span>
         <span class="k">for</span> edge <span class="k">in</span> bm.edges:
             edge.smooth = <span class="k">True</span>
             <span class="k">if</span> edge.is_manifold <span class="k">and</span> len(edge.link_faces) == <span class="n">2</span>:
-                <span class="k">if</span> edge.calc_face_angle() &gt; math.radians(<span class="n">35.0</span>):
+                <span class="k">if</span> edge.calc_face_angle() &gt; math.radians(<span class="n">40.0</span>):
                     edge.smooth = <span class="k">False</span>
-        <span class="k">for</span> f <span class="k">in</span> metal_faces:
-            <span class="k">if</span> f.is_valid:
-                f.material_index = METAL_IDX
         me = bpy.data.meshes.new(name)
         bm.to_mesh(me)
         me.update()
@@ -613,27 +746,45 @@ <h2>Source</h2>
     bpy.context.collection.objects.link(obj)
     <span class="k">return</span> obj
 
-<span class="k">def</span> principled(name, color, metallic, roughness):
+
+<span class="k">def</span> principled(name, color, metallic, roughness, noise_scale=<span class="n">0.0</span>, wear=<span class="k">None</span>):
     mat = bpy.data.materials.new(name)
     mat.use_nodes = <span class="k">True</span>
-    bsdf = mat.node_tree.nodes[<span class="s">&quot;Principled BSDF&quot;</span>]
+    nt = mat.node_tree
+    bsdf = nt.nodes[<span class="s">&quot;Principled BSDF&quot;</span>]
     bsdf.inputs[<span class="s">&quot;Base Color&quot;</span>].default_value = color
     bsdf.inputs[<span class="s">&quot;Metallic&quot;</span>].default_value = metallic
     bsdf.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = roughness
+    <span class="k">if</span> noise_scale &gt; <span class="n">0.0</span> <span class="k">and</span> wear <span class="k">is</span> <span class="k">not</span> <span class="k">None</span>:
+        tex = nt.nodes.new(<span class="s">&quot;ShaderNodeTexNoise&quot;</span>)
+        tex.inputs[<span class="s">&quot;Scale&quot;</span>].default_value = noise_scale
+        tex.inputs[<span class="s">&quot;Detail&quot;</span>].default_value = <span class="n">8.0</span>
+        tex.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.55</span>
+        mix = nt.nodes.new(<span class="s">&quot;ShaderNodeMix&quot;</span>)
+        mix.data_type = <span class="s">&quot;RGBA&quot;</span>
+        mix.inputs[<span class="s">&quot;A&quot;</span>].default_value = color
+        mix.inputs[<span class="s">&quot;B&quot;</span>].default_value = wear
+        fac = mix.inputs.get(<span class="s">&quot;Factor&quot;</span>) <span class="k">or</span> mix.inputs.get(<span class="s">&quot;Fac&quot;</span>)
+        nt.links.new(tex.outputs[<span class="s">&quot;Fac&quot;</span>], fac)
+        nt.links.new(mix.outputs[<span class="s">&quot;Result&quot;</span>], bsdf.inputs[<span class="s">&quot;Base Color&quot;</span>])
+        rmix = nt.nodes.new(<span class="s">&quot;ShaderNodeMix&quot;</span>)
+        rmix.data_type = <span class="s">&quot;FLOAT&quot;</span>
+        rmix.inputs[<span class="s">&quot;A&quot;</span>].default_value = roughness
+        rmix.inputs[<span class="s">&quot;B&quot;</span>].default_value = min(<span class="n">1.0</span>, roughness + <span class="n">0.18</span>)
+        rfac = rmix.inputs.get(<span class="s">&quot;Factor&quot;</span>) <span class="k">or</span> rmix.inputs.get(<span class="s">&quot;Fac&quot;</span>)
+        nt.links.new(tex.outputs[<span class="s">&quot;Fac&quot;</span>], rfac)
+        nt.links.new(rmix.outputs[<span class="s">&quot;Result&quot;</span>], bsdf.inputs[<span class="s">&quot;Roughness&quot;</span>])
     <span class="k">return</span> mat
 
 
 <span class="k">def</span> assign_slots(obj, wood, metal):
     mats = obj.data.materials
-    <span class="k">if</span> len(mats) == <span class="n">0</span>:
-        mats.append(wood)
-        mats.append(metal)
-        <span class="k">return</span>
-    mats[<span class="n">0</span>] = wood
-    <span class="k">if</span> len(mats) == <span class="n">1</span>:
-        mats.append(metal)
-    <span class="k">else</span>:
-        mats[<span class="n">1</span>] = metal
+    wanted = (wood, metal)
+    <span class="k">for</span> i, mat <span class="k">in</span> enumerate(wanted):
+        <span class="k">if</span> i &lt; len(mats):
+            mats[i] = mat
+        <span class="k">else</span>:
+            mats.append(mat)
 
 
 <span class="k">def</span> world_bbox(obj):
@@ -669,6 +820,253 @@ <h2>Source</h2>
     <span class="k">return</span> min(us), min(vs), max(us), max(vs), overlap, len(aabbs)
 
 
+<span class="k">def</span> face_area(me, poly):
+    idxs = poly.vertices
+    <span class="k">if</span> len(idxs) &lt; <span class="n">3</span>:
+        <span class="k">return</span> <span class="n">0.0</span>
+    v0 = me.vertices[idxs[<span class="n">0</span>]].co
+    area = <span class="n">0.0</span>
+    <span class="k">for</span> i <span class="k">in</span> range(<span class="n">1</span>, len(idxs) - <span class="n">1</span>):
+        vs = (me.vertices[idxs[i]].co, me.vertices[idxs[i + <span class="n">1</span>]].co)
+        area += (vs[<span class="n">0</span>] - v0).cross(vs[<span class="n">1</span>] - v0).length * <span class="n">0.5</span>
+    <span class="k">return</span> area
+
+
+<span class="k">def</span> hygiene_audit(me):
+    nv, ne, nf = len(me.vertices), len(me.edges), len(me.polygons)
+    ngons = sum(<span class="n">1</span> <span class="k">for</span> p <span class="k">in</span> me.polygons <span class="k">if</span> len(p.vertices) &gt; <span class="n">4</span>)
+    zero_area = sum(<span class="n">1</span> <span class="k">for</span> p <span class="k">in</span> me.polygons <span class="k">if</span> face_area(me, p) &lt;= AREA_EPS)
+    bm = bmesh.new()
+    <span class="k">try</span>:
+        bm.from_mesh(me)
+        bm.verts.ensure_lookup_table()
+        bm.edges.ensure_lookup_table()
+        loose_v = sum(<span class="n">1</span> <span class="k">for</span> v <span class="k">in</span> bm.verts <span class="k">if</span> len(v.link_edges) == <span class="n">0</span>)
+        loose_e = sum(<span class="n">1</span> <span class="k">for</span> e <span class="k">in</span> bm.edges <span class="k">if</span> len(e.link_faces) == <span class="n">0</span>)
+        nonman = sum(<span class="n">1</span> <span class="k">for</span> e <span class="k">in</span> bm.edges <span class="k">if</span> <span class="k">not</span> e.is_manifold)
+        ret = bmesh.ops.find_doubles(bm, verts=list(bm.verts), dist=DOUBLES_EPS)
+        doubles = len(ret.get(<span class="s">&quot;targetmap&quot;</span>) <span class="k">or</span> {})
+    <span class="k">finally</span>:
+        bm.free()
+    <span class="k">return</span> {
+        <span class="s">&quot;nv&quot;</span>: nv, <span class="s">&quot;ne&quot;</span>: ne, <span class="s">&quot;nf&quot;</span>: nf, <span class="s">&quot;ngons&quot;</span>: ngons,
+        <span class="s">&quot;loose_v&quot;</span>: loose_v, <span class="s">&quot;loose_e&quot;</span>: loose_e, <span class="s">&quot;nonman&quot;</span>: nonman,
+        <span class="s">&quot;zero_area&quot;</span>: zero_area, <span class="s">&quot;doubles&quot;</span>: doubles, <span class="s">&quot;euler&quot;</span>: nv - ne + nf,
+    }
+
+
+<span class="k">def</span> zfight_pairs(me):
+    data = [
+        (p.center.copy(), p.normal.copy(), frozenset(p.vertices))
+        <span class="k">for</span> p <span class="k">in</span> me.polygons
+    ]
+    eps2 = ZFIGHT_EPS * ZFIGHT_EPS
+    count = <span class="n">0</span>
+    <span class="k">for</span> i <span class="k">in</span> range(len(data)):
+        ci, ni, vi = data[i]
+        <span class="k">for</span> j <span class="k">in</span> range(i + <span class="n">1</span>, len(data)):
+            cj, nj, vj = data[j]
+            <span class="k">if</span> (cj - ci).length_squared &gt; eps2:
+                <span class="k">continue</span>
+            <span class="k">if</span> abs(ni.dot(nj)) &lt;= ZFIGHT_COS:
+                <span class="k">continue</span>
+            <span class="k">if</span> vi &amp; vj:
+                <span class="k">continue</span>
+            count += <span class="n">1</span>
+    <span class="k">return</span> count
+
+
+<span class="k">def</span> shells(me):
+    neighbors = [[] <span class="k">for</span> _ <span class="k">in</span> range(len(me.vertices))]
+    <span class="k">for</span> edge <span class="k">in</span> me.edges:
+        a, b = edge.vertices
+        neighbors[a].append(b)
+        neighbors[b].append(a)
+    seen = [<span class="k">False</span>] * len(me.vertices)
+    groups = []
+    <span class="k">for</span> start <span class="k">in</span> range(len(me.vertices)):
+        <span class="k">if</span> seen[start]:
+            <span class="k">continue</span>
+        seen[start] = <span class="k">True</span>
+        stack = [start]
+        group = []
+        <span class="k">while</span> stack:
+            current = stack.pop()
+            group.append(current)
+            <span class="k">for</span> nxt <span class="k">in</span> neighbors[current]:
+                <span class="k">if</span> <span class="k">not</span> seen[nxt]:
+                    seen[nxt] = <span class="k">True</span>
+                    stack.append(nxt)
+        groups.append(group)
+    <span class="k">return</span> groups
+
+
+<span class="k">def</span> shell_aabb(me, group):
+    pts = [me.vertices[i].co <span class="k">for</span> i <span class="k">in</span> group]
+    <span class="k">return</span> (
+        min(p.x <span class="k">for</span> p <span class="k">in</span> pts), min(p.y <span class="k">for</span> p <span class="k">in</span> pts), min(p.z <span class="k">for</span> p <span class="k">in</span> pts),
+        max(p.x <span class="k">for</span> p <span class="k">in</span> pts), max(p.y <span class="k">for</span> p <span class="k">in</span> pts), max(p.z <span class="k">for</span> p <span class="k">in</span> pts),
+    )
+
+
+<span class="k">def</span> mat_of(me, group):
+    member = set(group)
+    <span class="k">for</span> p <span class="k">in</span> me.polygons:
+        <span class="k">if</span> all(i <span class="k">in</span> member <span class="k">for</span> i <span class="k">in</span> p.vertices):
+            <span class="k">return</span> p.material_index
+    <span class="k">return</span> <span class="k">None</span>
+
+
+<span class="k">def</span> support_audit(me):
+    groups = shells(me)
+    cups = []
+    <span class="k">for</span> g <span class="k">in</span> groups:
+        <span class="k">if</span> mat_of(me, g) != METAL_IDX:
+            <span class="k">continue</span>
+        a = shell_aabb(me, g)
+        dx, dy, dz = a[<span class="n">3</span>] - a[<span class="n">0</span>], a[<span class="n">4</span>] - a[<span class="n">1</span>], a[<span class="n">5</span>] - a[<span class="n">2</span>]
+        <span class="k">if</span> a[<span class="n">5</span>] &lt; <span class="n">0.08</span> <span class="k">and</span> dx &gt; <span class="n">0.03</span> <span class="k">and</span> dy &gt; <span class="n">0.03</span> <span class="k">and</span> dz &lt; <span class="n">0.05</span>:
+            cups.append(a)
+    cup_z = min((a[<span class="n">2</span>] <span class="k">for</span> a <span class="k">in</span> cups), default=<span class="n">99.0</span>)
+    <span class="k">return</span> {<span class="s">&quot;cups&quot;</span>: len(cups), <span class="s">&quot;cup_z&quot;</span>: cup_z}
+
+
+<span class="k">def</span> seat_audit(me):
+    groups = shells(me)
+    best = <span class="k">None</span>
+    best_area = -<span class="n">1.0</span>
+    <span class="k">for</span> g <span class="k">in</span> groups:
+        <span class="k">if</span> mat_of(me, g) != WOOD_IDX:
+            <span class="k">continue</span>
+        a = shell_aabb(me, g)
+        dx, dy, dz = a[<span class="n">3</span>] - a[<span class="n">0</span>], a[<span class="n">4</span>] - a[<span class="n">1</span>], a[<span class="n">5</span>] - a[<span class="n">2</span>]
+        area = dx * dy
+        <span class="k">if</span> dz &gt; <span class="n">0.02</span> <span class="k">and</span> area &gt; best_area:
+            best_area = area
+            best = a
+    <span class="k">if</span> best <span class="k">is</span> <span class="k">None</span>:
+        <span class="k">return</span> {<span class="s">&quot;dia&quot;</span>: <span class="n">0.0</span>, <span class="s">&quot;height&quot;</span>: <span class="n">0.0</span>, <span class="s">&quot;zmin&quot;</span>: <span class="n">99.0</span>}
+    dia = <span class="n">0.5</span> * ((best[<span class="n">3</span>] - best[<span class="n">0</span>]) + (best[<span class="n">4</span>] - best[<span class="n">1</span>]))
+    <span class="k">return</span> {<span class="s">&quot;dia&quot;</span>: dia, <span class="s">&quot;height&quot;</span>: best[<span class="n">5</span>], <span class="s">&quot;zmin&quot;</span>: best[<span class="n">2</span>]}
+
+
+<span class="k">def</span> stretcher_join(me):
+    <span class="s">&quot;&quot;&quot;Worst gap from a stretcher shell to the nearest leg.&quot;&quot;&quot;</span>
+    groups = shells(me)
+    legs = []
+    stretchers = []
+    <span class="k">for</span> g <span class="k">in</span> groups:
+        <span class="k">if</span> mat_of(me, g) != WOOD_IDX:
+            <span class="k">continue</span>
+        a = shell_aabb(me, g)
+        dx, dy, dz = a[<span class="n">3</span>] - a[<span class="n">0</span>], a[<span class="n">4</span>] - a[<span class="n">1</span>], a[<span class="n">5</span>] - a[<span class="n">2</span>]
+        <span class="k">if</span> dz &gt; <span class="n">0.20</span> <span class="k">and</span> max(dx, dy) &lt; <span class="n">0.16</span>:
+            legs.append(g)
+        <span class="k">elif</span> dz &lt; <span class="n">0.035</span> <span class="k">and</span> <span class="n">0.10</span> &lt; max(dx, dy) &lt; <span class="n">0.30</span>:
+            stretchers.append(g)
+    <span class="k">if</span> <span class="k">not</span> legs <span class="k">or</span> <span class="k">not</span> stretchers:
+        <span class="k">return</span> <span class="n">99.0</span>
+    bm_leg = bmesh.new()
+    <span class="k">try</span>:
+        bm_leg.from_mesh(me)
+        keep = set()
+        <span class="k">for</span> g <span class="k">in</span> legs:
+            keep.update(g)
+        drop = [
+            f <span class="k">for</span> f <span class="k">in</span> bm_leg.faces
+            <span class="k">if</span> <span class="k">not</span> all(v.index <span class="k">in</span> keep <span class="k">for</span> v <span class="k">in</span> f.verts)
+        ]
+        <span class="k">if</span> drop:
+            bmesh.ops.delete(bm_leg, geom=drop, context=<span class="s">&quot;FACES&quot;</span>)
+        <span class="k">if</span> <span class="k">not</span> bm_leg.faces:
+            <span class="k">return</span> <span class="n">99.0</span>
+        tree = BVHTree.FromBMesh(bm_leg)
+        worst = <span class="n">0.0</span>
+        <span class="k">for</span> g <span class="k">in</span> stretchers:
+            bm_s = bmesh.new()
+            <span class="k">try</span>:
+                bm_s.from_mesh(me)
+                member = set(g)
+                drop_s = [
+                    f <span class="k">for</span> f <span class="k">in</span> bm_s.faces
+                    <span class="k">if</span> <span class="k">not</span> all(v.index <span class="k">in</span> member <span class="k">for</span> v <span class="k">in</span> f.verts)
+                ]
+                <span class="k">if</span> drop_s:
+                    bmesh.ops.delete(bm_s, geom=drop_s, context=<span class="s">&quot;FACES&quot;</span>)
+                <span class="k">if</span> <span class="k">not</span> bm_s.faces:
+                    worst = max(worst, <span class="n">99.0</span>)
+                    <span class="k">continue</span>
+                tree_s = BVHTree.FromBMesh(bm_s)
+                <span class="k">if</span> tree.overlap(tree_s):
+                    <span class="k">continue</span>
+                best = <span class="n">99.0</span>
+                <span class="k">for</span> i <span class="k">in</span> g:
+                    hit = tree.find_nearest(me.vertices[i].co)
+                    <span class="k">if</span> hit[<span class="n">0</span>] <span class="k">is</span> <span class="k">None</span>:
+                        <span class="k">continue</span>
+                    best = min(best, hit[<span class="n">3</span>])
+                <span class="k">if</span> best &gt; worst:
+                    worst = best
+            <span class="k">finally</span>:
+                bm_s.free()
+        <span class="k">return</span> worst
+    <span class="k">finally</span>:
+        bm_leg.free()
+
+
+<span class="k">def</span> ferrule_bite(me):
+    <span class="s">&quot;&quot;&quot;How far the ferrule inner wall sits inside the foot radius.
+
+    Sample metal verts on the inner ring (closest to the foot axis) against
+    wood at the same angle. A torus planted around the foot has no inner
+    bite; a cup does.
+    &quot;&quot;&quot;</span>
+    groups = shells(me)
+    cups = []
+    woods = []
+    <span class="k">for</span> g <span class="k">in</span> groups:
+        a = shell_aabb(me, g)
+        <span class="k">if</span> mat_of(me, g) == METAL_IDX <span class="k">and</span> a[<span class="n">5</span>] &lt; <span class="n">0.08</span>:
+            cups.append(g)
+        <span class="k">elif</span> mat_of(me, g) == WOOD_IDX <span class="k">and</span> a[<span class="n">2</span>] &lt; <span class="n">0.08</span> <span class="k">and</span> (a[<span class="n">5</span>] - a[<span class="n">2</span>]) &gt; <span class="n">0.15</span>:
+            woods.append(g)
+    <span class="k">if</span> <span class="k">not</span> cups <span class="k">or</span> <span class="k">not</span> woods:
+        <span class="k">return</span> <span class="n">0.0</span>
+    wood_pts = [me.vertices[i].co <span class="k">for</span> g <span class="k">in</span> woods <span class="k">for</span> i <span class="k">in</span> g <span class="k">if</span> me.vertices[i].co.z &lt; <span class="n">0.08</span>]
+    <span class="k">if</span> <span class="k">not</span> wood_pts:
+        <span class="k">return</span> <span class="n">0.0</span>
+    bites = []
+    <span class="k">for</span> g <span class="k">in</span> cups:
+        pts = [me.vertices[i].co <span class="k">for</span> i <span class="k">in</span> g]
+        cx = sum(p.x <span class="k">for</span> p <span class="k">in</span> pts) / len(pts)
+        cy = sum(p.y <span class="k">for</span> p <span class="k">in</span> pts) / len(pts)
+        inner = min(pts, key=<span class="k">lambda</span> p: (p.x - cx) ** <span class="n">2</span> + (p.y - cy) ** <span class="n">2</span>)
+        r_in = math.hypot(inner.x - cx, inner.y - cy)
+        ring = [
+            p <span class="k">for</span> p <span class="k">in</span> wood_pts
+            <span class="k">if</span> <span class="n">0.008</span> &lt; math.hypot(p.x - cx, p.y - cy) &lt; <span class="n">0.06</span> <span class="k">and</span> p.z &lt; <span class="n">0.05</span>
+        ]
+        <span class="k">if</span> <span class="k">not</span> ring:
+            <span class="k">continue</span>
+        foot = min(ring, key=<span class="k">lambda</span> p: math.hypot(p.x - cx, p.y - cy))
+        r_wood = math.hypot(foot.x - cx, foot.y - cy)
+        bites.append(r_wood - r_in)
+    <span class="k">if</span> <span class="k">not</span> bites:
+        <span class="k">return</span> <span class="n">0.0</span>
+    <span class="k">return</span> min(bites)
+
+
+<span class="k">def</span> add_stray_vert(me):
+    bm = bmesh.new()
+    <span class="k">try</span>:
+        bm.from_mesh(me)
+        bm.verts.new((<span class="n">0.0</span>, <span class="n">0.0</span>, SEAT_Z))
+        bm.to_mesh(me)
+        me.update()
+    <span class="k">finally</span>:
+        bm.free()
+
+
 <span class="k">def</span> make_lod(obj, name, ratio, skip_decimate):
     mesh = obj.data.copy()
     lod = bpy.data.objects.new(name, mesh)
@@ -682,7 +1080,6 @@ <h2>Source</h2>
 
 
 <span class="k">def</span> convex_hull_collider(obj, name):
-    <span class="c"># Duplicated from snippets/convex_hull_collider.py (not a package).</span>
     mesh = bpy.data.meshes.new(name)
     bm = bmesh.new()
     <span class="k">try</span>:
@@ -705,7 +1102,6 @@ <h2>Source</h2>
 
 
 <span class="k">def</span> setup_bake_image(obj, target_mat, size=BAKE_RES):
-    <span class="c"># Adapted from snippets/setup_bake_target_image.py — do not replace slots.</span>
     <span class="k">if</span> <span class="k">not</span> obj.data.uv_layers:
         <span class="k">return</span> <span class="k">None</span>, <span class="k">None</span>
     img = bpy.data.images.new(<span class="s">&quot;StoolNrm&quot;</span>, size, size, alpha=<span class="k">True</span>, float_buffer=<span class="k">False</span>)
@@ -720,7 +1116,6 @@ <h2>Source</h2>
 
 
 <span class="k">def</span> bake_normal(high, low):
-    <span class="c"># Duplicated from snippets/bake_normal_high_to_low.py (not a package).</span>
     scene = bpy.context.scene
     scene.render.engine = <span class="s">&quot;CYCLES&quot;</span>
     scene.cycles.device = <span class="s">&quot;CPU&quot;</span>
@@ -745,7 +1140,6 @@ <h2>Source</h2>
 
 
 <span class="k">def</span> export_unity(path, objects):
-    <span class="c"># Duplicated from snippets/export_preset_unity.py (not a package).</span>
     <span class="k">for</span> ob <span class="k">in</span> bpy.context.view_layer.objects:
         ob.select_set(<span class="k">False</span>)
     <span class="k">for</span> ob <span class="k">in</span> objects:
@@ -761,14 +1155,39 @@ <h2>Source</h2>
     )
 
 
-<span class="k">def</span> check(skip_decimate):
+<span class="k">def</span> check(
+    skip_decimate,
+    lift_z=<span class="k">False</span>,
+    stray_vert=<span class="k">False</span>,
+    short_legs=<span class="k">False</span>,
+    float_stretchers=<span class="k">False</span>,
+    pipe_ferrule=<span class="k">False</span>,
+):
     bpy.ops.wm.read_factory_settings(use_empty=<span class="k">True</span>)
-    low = build_stool_mesh(<span class="s">&quot;StoolLow&quot;</span>, bevel_offset=<span class="n">0.003</span>, bevel_segments=<span class="n">2</span>)
-    high = build_stool_mesh(<span class="s">&quot;StoolHigh&quot;</span>, bevel_offset=<span class="n">0.003</span>, bevel_segments=<span class="n">4</span>)
-    wood = principled(<span class="s">&quot;StoolWood&quot;</span>, (<span class="n">0.44</span>, <span class="n">0.26</span>, <span class="n">0.10</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.48</span>)
-    metal = principled(<span class="s">&quot;StoolMetal&quot;</span>, (<span class="n">0.55</span>, <span class="n">0.52</span>, <span class="n">0.48</span>, <span class="n">1.0</span>), <span class="n">1.0</span>, <span class="n">0.28</span>)
+    flags = dict(
+        short_legs=short_legs,
+        float_stretchers=float_stretchers,
+        pipe_ferrule=pipe_ferrule,
+    )
+    low = build_stool_mesh(<span class="s">&quot;StoolLow&quot;</span>, **flags)
+    high = build_stool_mesh(<span class="s">&quot;StoolHigh&quot;</span>, **flags)
+    wood = principled(
+        <span class="s">&quot;StoolWood&quot;</span>, (<span class="n">0.46</span>, <span class="n">0.26</span>, <span class="n">0.10</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.50</span>,
+        noise_scale=<span class="n">7.0</span>, wear=(<span class="n">0.28</span>, <span class="n">0.14</span>, <span class="n">0.05</span>, <span class="n">1.0</span>),
+    )
+    metal = principled(
+        <span class="s">&quot;StoolMetal&quot;</span>, (<span class="n">0.50</span>, <span class="n">0.48</span>, <span class="n">0.44</span>, <span class="n">1.0</span>), <span class="n">1.0</span>, <span class="n">0.32</span>,
+        noise_scale=<span class="n">5.0</span>, wear=(<span class="n">0.22</span>, <span class="n">0.20</span>, <span class="n">0.18</span>, <span class="n">1.0</span>),
+    )
     assign_slots(low, wood, metal)
     assign_slots(high, wood, metal)
+    <span class="k">if</span> stray_vert:
+        add_stray_vert(low.data)
+    <span class="k">if</span> lift_z:
+        <span class="k">for</span> v <span class="k">in</span> low.data.vertices:
+            v.co.z += LIFT_Z
+        low.data.update()
+        bpy.context.view_layer.update()
 
     <span class="k">if</span> low.data <span class="k">is</span> <span class="k">None</span> <span class="k">or</span> len(low.data.polygons) &lt; <span class="n">6</span>:
         <span class="k">return</span> fail(<span class="s">&quot;stool 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>
@@ -800,7 +1219,7 @@ <h2>Source</h2>
     r1 = lod1_tris / base_tris <span class="k">if</span> base_tris <span class="k">else</span> <span class="n">0.0</span>
     r2 = lod2_tris / base_tris <span class="k">if</span> base_tris <span class="k">else</span> <span class="n">0.0</span>
 
-    collider_src = build_stool_mesh(<span class="s">&quot;StoolColSrc&quot;</span>, bevel_offset=<span class="n">0.0</span>, bevel_segments=<span class="n">1</span>)
+    collider_src = build_stool_mesh(<span class="s">&quot;StoolColSrc&quot;</span>, **flags)
     collider = convex_hull_collider(collider_src, <span class="s">&quot;StoolCollider&quot;</span>)
     bpy.data.objects.remove(collider_src, do_unlink=<span class="k">True</span>)
     col_tris = triangle_count(collider.data)
@@ -814,9 +1233,14 @@ <h2>Source</h2>
     export_unity(export_path, [low, collider])
     export_size = os.path.getsize(export_path) <span class="k">if</span> os.path.isfile(export_path) <span class="k">else</span> <span class="n">0</span>
 
-    print(
-        <span class="s">f&quot;</span><span class="s">blender=</span>{tuple(bpy.app.version)}<span class="s"> skip_decimate=</span>{skip_decimate}<span class="s">&quot;</span>
-    )
+    hyg = hygiene_audit(low.data)
+    zf = zfight_pairs(low.data)
+    sup = support_audit(low.data)
+    st = seat_audit(low.data)
+    sj = stretcher_join(low.data)
+    bite = ferrule_bite(low.data)
+
+    print(<span class="s">f&quot;</span><span class="s">blender=</span>{tuple(bpy.app.version)}<span class="s"> skip_decimate=</span>{skip_decimate}<span class="s">&quot;</span>)
     print(
         <span class="s">f&quot;</span><span class="s">measured base_tris=</span>{base_tris}<span class="s"> lod1_tris=</span>{lod1_tris}<span class="s"> </span><span class="s">&quot;</span>
         <span class="s">f&quot;</span><span class="s">lod2_tris=</span>{lod2_tris}<span class="s"> r1=</span>{r1:<span class="s">.4f</span>}<span class="s"> r2=</span>{r2:<span class="s">.4f</span>}<span class="s">&quot;</span>
@@ -833,6 +1257,16 @@ <h2>Source</h2>
         <span class="s">f&quot;</span><span class="s">measured collider_tris=</span>{col_tris}<span class="s"> bake=</span>{bake_result}<span class="s"> </span><span class="s">&quot;</span>
         <span class="s">f&quot;</span><span class="s">bake_has_data=</span>{img.has_data}<span class="s"> export_bytes=</span>{export_size}<span class="s">&quot;</span>
     )
+    print(
+        <span class="s">f&quot;</span><span class="s">measured hygiene loose_v=</span>{hyg[<span class="s">&#x27;loose_v&#x27;</span>]}<span class="s"> loose_e=</span>{hyg[<span class="s">&#x27;loose_e&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">nonman=</span>{hyg[<span class="s">&#x27;nonman&#x27;</span>]}<span class="s"> zero_area=</span>{hyg[<span class="s">&#x27;zero_area&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">doubles=</span>{hyg[<span class="s">&#x27;doubles&#x27;</span>]}<span class="s"> ngons=</span>{hyg[<span class="s">&#x27;ngons&#x27;</span>]}<span class="s"> zfight=</span>{zf}<span class="s">&quot;</span>
+    )
+    print(
+        <span class="s">f&quot;</span><span class="s">measured supports cups=</span>{sup[<span class="s">&#x27;cups&#x27;</span>]}<span class="s"> cup_z=</span>{sup[<span class="s">&#x27;cup_z&#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">seat_dia=</span>{st[<span class="s">&#x27;dia&#x27;</span>]:<span class="s">.4f</span>}<span class="s"> seat_h=</span>{st[<span class="s">&#x27;height&#x27;</span>]:<span class="s">.4f</span>}<span class="s"> </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">stretch_join=</span>{sj:<span class="s">.5f</span>}<span class="s"> ferrule_bite=</span>{bite:<span class="s">.5f</span>}<span class="s">&quot;</span>
+    )
 
     <span class="k">if</span> <span class="k">not</span> (BASE_TRIS_MIN &lt;= base_tris &lt;= BASE_TRIS_MAX):
         <span class="k">return</span> fail(
@@ -897,6 +1331,51 @@ <h2>Source</h2>
         ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
     <span class="k">if</span> export_size &lt;= <span class="n">0</span>:
         <span class="k">return</span> fail(<span class="s">&quot;export file missing or empty&quot;</span>, <span class="n">13</span>), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+    <span class="k">if</span> (
+        hyg[<span class="s">&quot;loose_v&quot;</span>] <span class="k">or</span> hyg[<span class="s">&quot;loose_e&quot;</span>] <span class="k">or</span> hyg[<span class="s">&quot;nonman&quot;</span>]
+        <span class="k">or</span> hyg[<span class="s">&quot;zero_area&quot;</span>] <span class="k">or</span> hyg[<span class="s">&quot;doubles&quot;</span>] <span class="k">or</span> hyg[<span class="s">&quot;ngons&quot;</span>] <span class="k">or</span> zf
+    ):
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">hygiene loose_v=</span>{hyg[<span class="s">&#x27;loose_v&#x27;</span>]}<span class="s"> loose_e=</span>{hyg[<span class="s">&#x27;loose_e&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">f&quot;</span><span class="s">nonman=</span>{hyg[<span class="s">&#x27;nonman&#x27;</span>]}<span class="s"> zero_area=</span>{hyg[<span class="s">&#x27;zero_area&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">f&quot;</span><span class="s">doubles=</span>{hyg[<span class="s">&#x27;doubles&#x27;</span>]}<span class="s"> ngons=</span>{hyg[<span class="s">&#x27;ngons&#x27;</span>]}<span class="s"> zfight=</span>{zf}<span class="s">&quot;</span>,
+            <span class="n">15</span>,
+        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+    <span class="k">if</span> abs(bb[<span class="n">2</span>]) &gt; ZMIN_EPS:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">zmin </span>{bb[<span class="n">2</span>]:<span class="s">.6f</span>}<span class="s"> not within </span>{ZMIN_EPS}<span class="s"> of 0 </span><span class="s">&quot;</span>
+            <span class="s">&quot;(--lift-z is the designed fail)&quot;</span>,
+            <span class="n">16</span>,
+        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+    <span class="k">if</span> sup[<span class="s">&quot;cups&quot;</span>] &lt; <span class="n">4</span> <span class="k">or</span> sup[<span class="s">&quot;cup_z&quot;</span>] &gt; FERRULE_Z_MAX:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">ferrule supports </span>{sup[<span class="s">&#x27;cups&#x27;</span>]}<span class="s"> cup_z=</span>{sup[<span class="s">&#x27;cup_z&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">&quot;(--short-legs 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> sj &gt; STRETCH_JOIN:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">stretcher-leg gap </span>{sj:<span class="s">.5f</span>}<span class="s"> &gt; </span>{STRETCH_JOIN}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">&quot;(--float-stretchers is the designed fail)&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> <span class="k">not</span> (FERRULE_BITE_MIN &lt;= bite &lt;= FERRULE_BITE_MAX):
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">ferrule bite </span>{bite:<span class="s">.5f</span>}<span class="s"> not in </span><span class="s">&quot;</span>
+            <span class="s">f&quot;</span><span class="s">[</span>{FERRULE_BITE_MIN}<span class="s">, </span>{FERRULE_BITE_MAX}<span class="s">] </span><span class="s">&quot;</span>
+            <span class="s">&quot;(--pipe-ferrule is the designed fail)&quot;</span>,
+            <span class="n">18</span>,
+        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+    <span class="k">if</span> abs(st[<span class="s">&quot;dia&quot;</span>] - BODY_DIA) &gt; BODY_DIA_TOL:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">seat diameter </span>{st[<span class="s">&#x27;dia&#x27;</span>]:<span class="s">.4f</span>}<span class="s"> off </span>{BODY_DIA}<span class="s">&quot;</span>,
+            <span class="n">19</span>,
+        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+    <span class="k">if</span> abs(st[<span class="s">&quot;height&quot;</span>] - BODY_H) &gt; BODY_H_TOL:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">seat height </span>{st[<span class="s">&#x27;height&#x27;</span>]:<span class="s">.4f</span>}<span class="s"> off </span>{BODY_H}<span class="s">&quot;</span>,
+            <span class="n">19</span>,
+        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
     <span class="k">return</span> <span class="n">0</span>, low, high, wood, tex, collider
 
 
@@ -964,7 +1443,7 @@ <h2>Source</h2>
     cam_data = bpy.data.cameras.new(<span class="s">&quot;Cam&quot;</span>)
     cam_data.lens = <span class="n">50.0</span>
     cam = bpy.data.objects.new(<span class="s">&quot;Cam&quot;</span>, cam_data)
-    cam.location = (<span class="n">0.94</span>, -<span class="n">1.26</span>, <span class="n">0.90</span>)
+    cam.location = (<span class="n">1.05</span>, -<span class="n">1.38</span>, <span class="n">0.92</span>)
     scene.collection.objects.link(cam)
     aim = bpy.data.objects.new(<span class="s">&quot;Aim&quot;</span>, <span class="k">None</span>)
     aim.location = (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.26</span>)
@@ -1010,14 +1489,22 @@ <h2>Source</h2>
     p = argparse.ArgumentParser()
     p.add_argument(<span class="s">&quot;--output&quot;</span>, default=<span class="k">None</span>)
     p.add_argument(<span class="s">&quot;--engine&quot;</span>, default=<span class="s">&quot;eevee&quot;</span>, choices=(<span class="s">&quot;eevee&quot;</span>, <span class="s">&quot;cycles&quot;</span>))
-    p.add_argument(
-        <span class="s">&quot;--skip-decimate&quot;</span>,
-        action=<span class="s">&quot;store_true&quot;</span>,
-        help=<span class="s">&quot;falsification: skip the LOD DECIMATE stage&quot;</span>,
-    )
+    p.add_argument(<span class="s">&quot;--skip-decimate&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--lift-z&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--stray-vert&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--short-legs&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--float-stretchers&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--pipe-ferrule&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
     args = p.parse_args(argv)
 
-    code, low, _high, wood, tex, _col = check(args.skip_decimate)
+    code, low, _high, wood, tex, _col = check(
+        args.skip_decimate,
+        lift_z=args.lift_z,
+        stray_vert=args.stray_vert,
+        short_legs=args.short_legs,
+        float_stretchers=args.float_stretchers,
+        pipe_ferrule=args.pipe_ferrule,
+    )
     <span class="k">if</span> code:
         <span class="k">return</span> code
     <span class="k">if</span> args.output:
diff --git a/docs/gallery/treasure-chest/index.html b/docs/gallery/treasure-chest/index.html
index f046b30..0b7af9d 100644
--- a/docs/gallery/treasure-chest/index.html
+++ b/docs/gallery/treasure-chest/index.html
@@ -4,18 +4,18 @@
   <meta charset="utf-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1" />
   <title>treasure-chest — Examples — Blender Developer Tools</title>
-  <meta name="description" content="A procedural slatted treasure chest through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
+  <meta name="description" content="A procedural iron-bound chest with a lofted barrel-vault lid, U-wrap bands, and hinge knuckles through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
   <link rel="canonical" href="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/treasure-chest/" />
   <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="treasure-chest — Examples — Blender Developer Tools" />
-  <meta property="og:description" content="A procedural slatted treasure chest through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
+  <meta property="og:description" content="A procedural iron-bound chest with a lofted barrel-vault lid, U-wrap bands, and hinge knuckles through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
   <meta property="og:url" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/treasure-chest/" />
   <meta property="og:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/treasure-chest-hero.webp" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="treasure-chest — Examples — Blender Developer Tools" />
-  <meta name="twitter:description" content="A procedural slatted treasure chest through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
+  <meta name="twitter:description" content="A procedural iron-bound chest with a lofted barrel-vault lid, U-wrap bands, and hinge knuckles through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
   <meta name="twitter:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/treasure-chest-hero.webp" />
   <style>
     /* fonts are deployed by the landing build (docs/fonts/) */
@@ -246,35 +246,48 @@
   </div>
   <header class="hero">
     <h1>treasure-chest</h1>
-    <p>A procedural slatted treasure chest through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.</p>
+    <p>A procedural iron-bound chest with a lofted barrel-vault lid, U-wrap bands, and hinge knuckles through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.</p>
   </header>
   <main id="main">
     <button class="detail-hero" id="heroZoom" type="button" aria-label="Zoom treasure-chest render">
       <img src="../assets/treasure-chest-hero.webp" alt="treasure-chest 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: 5724 tris, two materials with 180 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.776×0.549×0.631 m, LOD ratios in band, convex collider 138 tris, non-empty glTF. --skip-decimate exits 9 on the LOD1 ratio budget.</div>
+    <div class="callout"><span class="tag">witnesses</span> Recomputed: 3852 tris, two materials with 1608 wood and 318 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.764×0.542×0.691 m, LOD ratios in band, convex collider 176 tris, non-empty glTF. Hygiene all zero, four feet at zmin 0, lid-knuckle to hinge barrel 7 mm, band-wall gap 0. --float-hinge exits 17 on the hinge join; --narrow-bands exits 18 on the band seat.</div>
     <div class="runline">
       <pre id="runCmd">blender --background --python showcase/treasure-chest/treasure_chest.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 slatted treasure chest (hollow body, open lid, iron bands, corner brackets, lock plate) 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 iron-bound chest (slatted hollow body, barrel-vault lid, U-wrap bands, corner irons, lock plate, hinge barrels with lid knuckles, wooden feet) then the shipped pipeline: unique-cell UVs, Cycles high-to-low normal bake, LOD chain, convex collider, Unity glTF export.</p>
+<p>The lid is one lofted vault slab, not stacked boxes. Hinge join is measured from local lid knuckles over the barrels — a spanning stile only has verts at the X ends, 8 cm from the knuckles, and reports a false gap.</p>
 <p>It asserts <strong>budget conformance</strong> of the generated result. It does not witness an API contract. &quot;It rendered without error&quot; is not a check.</p>
 <p><strong>Composes</strong> skills <code>mesh-editing-and-bmesh</code>, <code>bake-high-to-low</code>, <code>depsgraph-and-evaluated-data</code>, <code>engine-export-presets</code>, and snippets <code>bake_normal_high_to_low.py</code>, <code>setup_bake_target_image.py</code>, <code>lod_chain.py</code> / <code>decimate_to_budget.py</code>, <code>convex_hull_collider.py</code>, <code>export_preset_unity.py</code> (helpers copied, not imported as a package).</p>
 <h2>Budgets</h2>
 <p>Declared as named constants; every gate <strong>recomputes</strong> from the mesh, materials, UVs, evaluated LOD, collider, or export file.</p>
-<p>| Axis | Declared | Measured (4.5.11 / 5.1.2 / 5.2.1) | | --- | --- | --- | | Base triangles | 5600–5850 | 5724 / 5724 / 5724 | | LOD1 ratio | 0.32–0.62 of base | 0.5000 / 0.5000 / 0.5000 | | LOD2 ratio | 0.10–0.35 of base | 0.2198 / 0.2198 / 0.2198 | | Materials | exactly 2 distinct, ≥24 metal faces | 2 slots, 180 metal | | UVs | in <code>0..1</code>, AABB overlap ≤ 1e-5 | in range, overlap 0 | | Outer AABB | (0.776, 0.549, 0.631) m ± 0.01 | (0.7760, 0.5486, 0.6312), zmin 0 | | Collider tris | ≤ 160 | 138 | | Export | written, size &gt; 0 | 416656 / 416656 / 416644 bytes |</p>
-<p>DECIMATE COLLAPSE triangle counts are <strong>not</strong> guaranteed identical across series — the gate is a ratio band, not an exact count. This mesh happened to match on 4.5.11 / 5.1.2 / 5.2.1. Bake pixels are stochastic; the gate is <code>has_data</code> plus operator <code>FINISHED</code>, not byte-identity. Construction uses no RNG. glTF byte size differs by a few bytes across series.</p>
-<p><code>--skip-decimate</code> skips the LOD DECIMATE stage so LOD1 ratio is 1.0 and exit 9 fires. That is the named budget the falsifier violates.</p>
+<p>| Axis | Declared | Measured (4.5.11 / 5.1.2 / 5.2.1) | | --- | --- | --- | | Base triangles | 3600–4500 | 3852 / 3852 / 3852 | | LOD1 ratio | 0.32–0.62 of base | 0.5000 / 0.5000 / 0.5000 | | LOD2 ratio | 0.10–0.35 of base | 0.2196 / 0.2196 / 0.2129 | | Materials | exactly 2 distinct; ≥200 wood, ≥80 metal faces | 2 slots; 1608 / 318 | | UVs | in <code>0..1</code>, AABB overlap ≤ 1e-5 | in range, overlap 0 | | Outer AABB | (0.764, 0.542, 0.691) m ± 0.015 | (0.7640, 0.5423, 0.6907), zmin 0 | | Collider tris | ≤ 200 | 176 | | Export | written, size &gt; 0 | 288196 / 288196 / 288184 bytes |</p>
+<h3>Hygiene</h3>
+<p>Recomputed from the generated mesh, not asserted about the script.</p>
+<p>| Axis | Declared | Measured (all three) | | --- | --- | --- | | Non-manifold edges | 0 | 0 | | Loose verts / edges | 0 / 0 | 0 / 0 | | Doubles merged at 1e-5 | 0 | 0 | | Zero-area faces | 0 | 0 | | N-gons | 0 | 0 | | Coplanar disjoint face pairs | 0 | 0 | | Grounded: <code>zmin</code> | within 1e-4 of 0 | 0.0000 | | Named supports: 4 feet | each <code>zmin</code> ≤ 1e-3 | 4, foot_z 0.00000 | | Body plan | 0.74 × 0.46 m ± 0.04 | 0.7400 × 0.4600 |</p>
+<h3>Joint fit and seat</h3>
+<p>| Axis | Declared | Measured (all three) | | --- | --- | --- | | Lid-knuckle to hinge barrel | ≤ 0.020 m | 0.00700 | | Band-wall BVH gap | ≤ 0.008 m | 0.00000 |</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 may differ by a few bytes across series.</p>
+<h3>Falsifiers</h3>
+<p>Each violates one named budget. All seven were run on 4.5.11, 5.1.2 and 5.2.1 and returned the same code on each.</p>
+<p>| Flag | Budget violated | Exit | | --- | --- | --- | | <code>--skip-decimate</code> | LOD1 ratio band | 9 | | <code>--stray-vert</code> | loose vertex count is 0 | 15 | | <code>--lift-z</code> | bounding box <code>zmin</code> is 0 | 16 | | <code>--short-legs</code> | named foot supports at Z=0 | 16 | | <code>--float-hinge</code> | lid-knuckle to hinge barrel | 17 | | <code>--narrow-bands</code> | band-wall seat | 18 |</p>
 <h2>Run</h2>
 <pre><code>blender --background --python treasure_chest.py --
 blender --background --python treasure_chest.py -- --skip-decimate
+blender --background --python treasure_chest.py -- --stray-vert
+blender --background --python treasure_chest.py -- --lift-z
+blender --background --python treasure_chest.py -- --short-legs
+blender --background --python treasure_chest.py -- --float-hinge
+blender --background --python treasure_chest.py -- --narrow-bands
 blender --background --python treasure_chest.py -- --output chest.png</code></pre>
-<p>Smoke does not pass <code>--output</code> or <code>--skip-decimate</code>.</p>
+<p>Smoke passes no flags.</p>
 <h2>Exit codes</h2>
-<p>File-local. <code>9</code> is a valid check code. <code>10</code> is reserved for <code>gallery_framing.check_framing</code> on the <code>--output</code> path.</p>
-<p>| Code | Meaning | | --- | --- | | 0 | Success | | 1 | Uncaught exception (FATAL wrapper) | | 2 | argparse / usage | | 3 | Mesh did not build / no UV layer | | 4 | Base triangle count outside range | | 5 | Material count ≠ 2 distinct slots, or metal faces missing | | 6 | UVs outside 0..1 | | 7 | UV AABB overlap above tolerance | | 8 | World AABB off declared outer size | | 9 | LOD ratio band (<code>--skip-decimate</code> lands here) | | 10 | Framing gate (render path only) | | 11 | Collider triangle count above ceiling | | 12 | Bake did not finish or image has no data | | 13 | Export file missing or empty | | 14 | <code>--output</code> produced no file |</p>
+<p>File-local. <code>9</code> is a valid check code. <code>10</code> is reserved for <code>gallery_framing.check_framing</code> on the <code>--output</code> path. <code>15</code>–<code>19</code> are the hygiene and joint-fit family.</p>
+<p>| Code | Meaning | | --- | --- | | 0 | Success | | 1 | Uncaught exception (FATAL wrapper) | | 2 | argparse / usage | | 3 | Mesh did not build / no UV layer | | 4 | Base triangle count outside range | | 5 | Material count ≠ 2 distinct slots, or a face-count floor missed | | 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: loose, non-manifold, zero-area, doubles, n-gons, z-fight | | 16 | Not grounded: bounding box <code>zmin</code> off 0, or a named foot floats | | 17 | Joint fit: lid-knuckle to hinge barrel | | 18 | Seat: band-wall gap | | 19 | Body plan off the stated real-world size |</p>
     </section>
     <section class="detail-section src">
       <h2>Source</h2>
@@ -289,8 +302,11 @@ <h2>Source</h2>
 normal bake, LOD chain, convex collider, Unity glTF export.
 
 Budgets are declared below and recomputed from the generated result.
-They are not API-contract witnesses. ``--skip-decimate`` skips the LOD
-DECIMATE stage so the LOD-ratio budget fails.
+They are not API-contract witnesses. Each falsifier violates one named
+budget: ``--skip-decimate`` the LOD-ratio band, ``--stray-vert`` mesh
+hygiene, ``--lift-z`` grounded zmin, ``--short-legs`` named foot
+supports, ``--float-hinge`` lid-hinge joint-fit, ``--narrow-bands``
+band-wall seat.
 
 No RNG. Construction is closed-form. DECIMATE COLLAPSE triangle counts
 are not byte-identical across Blender versions — the LOD gate is a
@@ -310,10 +326,8 @@ <h2>Source</h2>
 <span class="k">import</span> bmesh
 <span class="k">import</span> bpy
 <span class="k">from</span> mathutils <span class="k">import</span> Euler, Vector
+<span class="k">from</span> mathutils.bvhtree <span class="k">import</span> BVHTree
 
-<span class="c"># Showcase lives at repo-root/showcase/, not under examples/. The framing</span>
-<span class="c"># helper is the repo&#x27;s only shared import and lives next to the examples;</span>
-<span class="c"># resolve the repo root so we do not move gallery_framing.py.</span>
 _REPO = os.path.abspath(
     os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir, os.pardir)
 )
@@ -321,25 +335,37 @@ <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>
 
+<span class="c"># A small iron-bound chest: 0.74 × 0.46 m plan, ~0.37 m to the rim,</span>
+<span class="c"># shallow barrel-vault lid. The old piece was a crate of overlay boxes</span>
+<span class="c"># with a flat sandwich lid.</span>
 OUTER_W = <span class="n">0.74</span>
 OUTER_D = <span class="n">0.46</span>
-CAVITY_H = <span class="n">0.30</span>
-WALL = <span class="n">0.030</span>
-BOTTOM = <span class="n">0.028</span>
-FOOT_H = <span class="n">0.038</span>
-FOOT_S = <span class="n">0.072</span>
-LID_T = <span class="n">0.032</span>
-LID_LIP = <span class="n">0.042</span>
-SLAT_T = <span class="n">0.018</span>
+CAVITY_H = <span class="n">0.28</span>
+WALL = <span class="n">0.028</span>
+BOTTOM = <span class="n">0.026</span>
+FOOT_H = <span class="n">0.042</span>
+FOOT_S = <span class="n">0.068</span>
+FOOT_NEST = <span class="n">0.012</span>
+LID_T = <span class="n">0.028</span>
 N_FRONT = <span class="n">5</span>
+N_SIDE = <span class="n">4</span>
 N_LID = <span class="n">5</span>
-BAND_W = <span class="n">0.048</span>
-BAND_T = <span class="n">0.016</span>
-LID_ANGLE = math.radians(-<span class="n">26.0</span>)
-BBOX_TOL = <span class="n">0.01</span>
-OUTER_SIZE = (<span class="n">0.776</span>, <span class="n">0.549</span>, <span class="n">0.631</span>)
-BASE_TRIS_MIN = <span class="n">5600</span>
-BASE_TRIS_MAX = <span class="n">5850</span>
+BAND_W = <span class="n">0.042</span>
+BAND_T = <span class="n">0.010</span>
+VAULT_R = <span class="n">0.50</span>
+HINGE_R = <span class="n">0.011</span>
+LID_ANGLE = math.radians(-<span class="n">38.0</span>)
+BRACKET = <span class="n">0.050</span>
+IRON_T = <span class="n">0.012</span>
+BBOX_TOL = <span class="n">0.015</span>
+BODY_W = OUTER_W
+BODY_D = OUTER_D
+BODY_W_TOL = <span class="n">0.04</span>
+BODY_D_TOL = <span class="n">0.04</span>
+OUTER_SIZE = (<span class="n">0.764</span>, <span class="n">0.542</span>, <span class="n">0.691</span>)
+
+BASE_TRIS_MIN = <span class="n">3600</span>
+BASE_TRIS_MAX = <span class="n">4500</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>
@@ -349,10 +375,20 @@ <h2>Source</h2>
 MATERIAL_COUNT = <span class="n">2</span>
 UV_EPS = <span class="n">1e-4</span>
 UV_OVERLAP_MAX = <span class="n">1e-5</span>
-COLLIDER_TRIS_MAX = <span class="n">160</span>
+COLLIDER_TRIS_MAX = <span class="n">200</span>
 BAKE_RES = <span class="n">256</span>
 CAGE_EXTRUSION = <span class="n">0.06</span>
-METAL_FACES_MIN = <span class="n">24</span>
+METAL_FACES_MIN = <span class="n">80</span>
+WOOD_FACES_MIN = <span class="n">200</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">1e-4</span>
+ZFIGHT_COS = <span class="n">0.999</span>
+LIFT_Z = <span class="n">0.05</span>
+FOOT_Z_MAX = <span class="n">1e-3</span>
+HINGE_JOIN = <span class="n">0.020</span>
+BAND_SEAT = <span class="n">0.008</span>
 
 WOOD_IDX = <span class="n">0</span>
 METAL_IDX = <span class="n">1</span>
@@ -373,7 +409,6 @@ <h2>Source</h2>
 
 
 <span class="k">def</span> evaluated_triangle_count(obj):
-    <span class="c"># Duplicated from snippets/lod_chain.py / decimate_to_budget.py (not a package).</span>
     depsgraph = bpy.context.evaluated_depsgraph_get()
     eval_obj = obj.evaluated_get(depsgraph)
     eval_mesh = eval_obj.to_mesh()
@@ -395,6 +430,34 @@ <h2>Source</h2>
     faces = {f <span class="k">for</span> v <span class="k">in</span> verts <span class="k">for</span> f <span class="k">in</span> v.link_faces}
     <span class="k">for</span> f <span class="k">in</span> faces:
         f.material_index = mat_idx
+    <span class="k">return</span> list(verts)
+
+
+<span class="k">def</span> add_arc_slab(bm, cz, a0, a1, r_in, r_out, x0, x1, n, mat_idx):
+    <span class="s">&quot;&quot;&quot;Solid barrel-vault slab along X. Inner/outer arcs, two X stations.&quot;&quot;&quot;</span>
+    <span class="k">def</span> mk(x, r, t):
+        <span class="k">return</span> bm.verts.new((x, r * math.sin(t), cz + r * math.cos(t)))
+
+    rin, rout, lin, lout = [], [], [], []
+    <span class="k">for</span> i <span class="k">in</span> range(n + <span class="n">1</span>):
+        t = a0 + (a1 - a0) * (i / float(n))
+        rin.append(mk(x0, r_in, t))
+        rout.append(mk(x0, r_out, t))
+        lin.append(mk(x1, r_in, t))
+        lout.append(mk(x1, r_out, t))
+    verts = rin + rout + lin + lout
+
+    <span class="k">def</span> face(vs):
+        f = bm.faces.new(vs)
+        f.material_index = mat_idx
+
+    <span class="k">for</span> i <span class="k">in</span> range(n):
+        face((rin[i], lin[i], lin[i + <span class="n">1</span>], rin[i + <span class="n">1</span>]))
+        face((rout[i], rout[i + <span class="n">1</span>], lout[i + <span class="n">1</span>], lout[i]))
+        face((rin[i], rin[i + <span class="n">1</span>], rout[i + <span class="n">1</span>], rout[i]))
+        face((lin[i], lout[i], lout[i + <span class="n">1</span>], lin[i + <span class="n">1</span>]))
+    face((rin[<span class="n">0</span>], rout[<span class="n">0</span>], lout[<span class="n">0</span>], lin[<span class="n">0</span>]))
+    face((rin[-<span class="n">1</span>], lin[-<span class="n">1</span>], lout[-<span class="n">1</span>], rout[-<span class="n">1</span>]))
     <span class="k">return</span> verts
 
 
@@ -414,9 +477,7 @@ <h2>Source</h2>
         col = i % cols
         row = i // cols
         nrm = face.normal
-        ax = abs(nrm.x)
-        ay = abs(nrm.y)
-        az = abs(nrm.z)
+        ax, ay, az = abs(nrm.x), abs(nrm.y), abs(nrm.z)
         coords = []
         <span class="k">for</span> loop <span class="k">in</span> face.loops:
             co = loop.vert.co
@@ -441,31 +502,44 @@ <h2>Source</h2>
             )
 
 
-<span class="k">def</span> build_chest_mesh(name, bevel_offset, bevel_segments):
+<span class="k">def</span> build_chest_mesh(
+    name, bevel_offset, bevel_segments,
+    short_legs=<span class="k">False</span>, float_hinge=<span class="k">False</span>, narrow_bands=<span class="k">False</span>,
+):
     bm = bmesh.new()
     <span class="k">try</span>:
-        bevel_verts = []
-        lid_verts = []
-        body_top = FOOT_H + BOTTOM + CAVITY_H
+        wood = []
+        metal = []
+        lid_wood = []
+        lid_metal = []
         hx = OUTER_W / <span class="n">2.0</span>
         hy = OUTER_D / <span class="n">2.0</span>
+        body_top = FOOT_H + BOTTOM + CAVITY_H
+        wall_h = CAVITY_H
+        wall_z = FOOT_H + BOTTOM + wall_h / <span class="n">2.0</span>
+        foot_z0 = <span class="n">0.05</span> <span class="k">if</span> short_legs <span class="k">else</span> <span class="n">0.0</span>
+
+        <span class="k">if</span> short_legs:
+            metal.extend(
+                add_box(bm, (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.004</span>), (<span class="n">0.04</span>, <span class="n">0.04</span>, <span class="n">0.008</span>), METAL_IDX)
+            )
 
         <span class="k">for</span> sxn <span class="k">in</span> (-<span class="n">1.0</span>, <span class="n">1.0</span>):
             <span class="k">for</span> syn <span class="k">in</span> (-<span class="n">1.0</span>, <span class="n">1.0</span>):
-                bevel_verts.extend(
+                wood.extend(
                     add_box(
                         bm,
                         (
-                            sxn * (hx - FOOT_S / <span class="n">2.0</span> - <span class="n">0.01</span>),
-                            syn * (hy - FOOT_S / <span class="n">2.0</span> - <span class="n">0.01</span>),
-                            FOOT_H / <span class="n">2.0</span>,
+                            sxn * (hx - FOOT_S / <span class="n">2.0</span> - <span class="n">0.010</span>),
+                            syn * (hy - FOOT_S / <span class="n">2.0</span> - <span class="n">0.010</span>),
+                            foot_z0 + (FOOT_H + FOOT_NEST) / <span class="n">2.0</span>,
                         ),
-                        (FOOT_S, FOOT_S, FOOT_H),
-                        METAL_IDX,
+                        (FOOT_S, FOOT_S, FOOT_H + FOOT_NEST),
+                        WOOD_IDX,
                     )
                 )
 
-        bevel_verts.extend(
+        wood.extend(
             add_box(
                 bm,
                 (<span class="n">0.0</span>, <span class="n">0.0</span>, FOOT_H + BOTTOM / <span class="n">2.0</span>),
@@ -473,212 +547,240 @@ <h2>Source</h2>
                 WOOD_IDX,
             )
         )
-        wall_h = CAVITY_H
-        wall_z = FOOT_H + BOTTOM + wall_h / <span class="n">2.0</span>
-        bevel_verts.extend(
-            add_box(
-                bm,
-                (<span class="n">0.0</span>, -hy + WALL / <span class="n">2.0</span>, wall_z),
-                (OUTER_W, WALL, wall_h),
-                WOOD_IDX,
-            )
-        )
-        bevel_verts.extend(
-            add_box(
-                bm,
-                (<span class="n">0.0</span>, hy - WALL / <span class="n">2.0</span>, wall_z),
-                (OUTER_W, WALL, wall_h),
-                WOOD_IDX,
-            )
-        )
-        inner_d = OUTER_D - <span class="n">2.0</span> * WALL
-        bevel_verts.extend(
-            add_box(
-                bm,
-                (-hx + WALL / <span class="n">2.0</span>, <span class="n">0.0</span>, wall_z),
-                (WALL, inner_d, wall_h),
-                WOOD_IDX,
-            )
-        )
-        bevel_verts.extend(
-            add_box(
-                bm,
-                (hx - WALL / <span class="n">2.0</span>, <span class="n">0.0</span>, wall_z),
-                (WALL, inner_d, wall_h),
-                WOOD_IDX,
-            )
-        )
 
-        slat_w = (OUTER_W - <span class="n">0.06</span>) / N_FRONT
-        gap = <span class="n">0.006</span>
-        usable = slat_w - gap
-        x0 = -hx + <span class="n">0.03</span> + usable / <span class="n">2.0</span>
+        pitch = OUTER_W / N_FRONT
+        overlap = <span class="n">0.006</span>
         <span class="k">for</span> i <span class="k">in</span> range(N_FRONT):
-            x = x0 + i * slat_w
-            bevel_verts.extend(
+            jw = <span class="n">0.004</span> * math.sin(i * <span class="n">1.7</span> + <span class="n">0.4</span>)
+            x = -hx + pitch * (i + <span class="n">0.5</span>)
+            y_off = <span class="n">0.0015</span> <span class="k">if</span> (i % <span class="n">2</span>) <span class="k">else</span> <span class="n">0.0</span>
+            wood.extend(
+                add_box(
+                    bm,
+                    (x, -hy + WALL / <span class="n">2.0</span> + y_off, wall_z),
+                    (pitch + overlap + jw, WALL, wall_h),
+                    WOOD_IDX,
+                )
+            )
+            wood.extend(
                 add_box(
                     bm,
-                    (x, -hy - SLAT_T / <span class="n">2.0</span>, wall_z),
-                    (usable, SLAT_T, wall_h - <span class="n">0.02</span>),
+                    (x, hy - WALL / <span class="n">2.0</span> - y_off, wall_z),
+                    (pitch + overlap + jw, WALL, wall_h),
                     WOOD_IDX,
                 )
             )
 
-        n_side = <span class="n">3</span>
-        side_h = (wall_h - <span class="n">0.04</span>) / n_side
+        pitch_z = wall_h / N_SIDE
+        inner_d = OUTER_D - <span class="n">2.0</span> * WALL + <span class="n">0.010</span>
         <span class="k">for</span> sign <span class="k">in</span> (-<span class="n">1.0</span>, <span class="n">1.0</span>):
-            <span class="k">for</span> i <span class="k">in</span> range(n_side):
-                z = FOOT_H + BOTTOM + <span class="n">0.02</span> + side_h / <span class="n">2.0</span> + i * (side_h + <span class="n">0.006</span>)
-                bevel_verts.extend(
+            <span class="k">for</span> i <span class="k">in</span> range(N_SIDE):
+                jh = <span class="n">0.003</span> * math.sin(i * <span class="n">1.3</span> + sign)
+                z = FOOT_H + BOTTOM + pitch_z * (i + <span class="n">0.5</span>)
+                x_off = <span class="n">0.0015</span> <span class="k">if</span> (i % <span class="n">2</span>) <span class="k">else</span> <span class="n">0.0</span>
+                wood.extend(
                     add_box(
                         bm,
-                        (sign * (hx + SLAT_T / <span class="n">2.0</span>), <span class="n">0.0</span>, z),
-                        (SLAT_T, OUTER_D - <span class="n">0.08</span>, side_h - <span class="n">0.008</span>),
+                        (sign * (hx - WALL / <span class="n">2.0</span> - sign * x_off), <span class="n">0.0</span>, z),
+                        (WALL, inner_d, pitch_z + <span class="n">0.006</span> + jh),
                         WOOD_IDX,
                     )
                 )
 
+        rim_t = <span class="n">0.012</span>
+        rim_z = body_top - rim_t / <span class="n">2.0</span> - <span class="n">0.002</span>
+        wood.extend(
+            add_box(
+                bm, (<span class="n">0.0</span>, -hy + WALL + rim_t / <span class="n">2.0</span>, rim_z),
+                (OUTER_W - <span class="n">2.0</span> * WALL, rim_t, rim_t), WOOD_IDX,
+            )
+        )
+        wood.extend(
+            add_box(
+                bm, (<span class="n">0.0</span>, hy - WALL - rim_t / <span class="n">2.0</span>, rim_z),
+                (OUTER_W - <span class="n">2.0</span> * WALL, rim_t, rim_t), WOOD_IDX,
+            )
+        )
+        wood.extend(
+            add_box(
+                bm, (-hx + WALL + rim_t / <span class="n">2.0</span> + <span class="n">0.003</span>, <span class="n">0.0</span>, rim_z),
+                (rim_t, OUTER_D - <span class="n">2.0</span> * WALL - <span class="n">2.0</span> * rim_t - <span class="n">0.012</span>, rim_t), WOOD_IDX,
+            )
+        )
+        wood.extend(
+            add_box(
+                bm, (hx - WALL - rim_t / <span class="n">2.0</span> - <span class="n">0.003</span>, <span class="n">0.0</span>, rim_z),
+                (rim_t, OUTER_D - <span class="n">2.0</span> * WALL - <span class="n">2.0</span> * rim_t - <span class="n">0.012</span>, rim_t), WOOD_IDX,
+            )
+        )
+
+        band_t = <span class="n">0.004</span> <span class="k">if</span> narrow_bands <span class="k">else</span> BAND_T
+        band_y_off = <span class="n">0.022</span> <span class="k">if</span> narrow_bands <span class="k">else</span> <span class="n">0.0</span>
         band_xs = (-OUTER_W * <span class="n">0.32</span>, <span class="n">0.0</span>, OUTER_W * <span class="n">0.32</span>)
         <span class="k">for</span> bx <span class="k">in</span> band_xs:
-            bevel_verts.extend(
+            metal.extend(
                 add_box(
                     bm,
-                    (bx, -hy - BAND_T / <span class="n">2.0</span>, wall_z),
-                    (BAND_W, BAND_T, wall_h + <span class="n">0.01</span>),
+                    (
+                        bx,
+                        -hy - band_t / <span class="n">2.0</span> - band_y_off,
+                        FOOT_H + (wall_h + BOTTOM) / <span class="n">2.0</span>,
+                    ),
+                    (BAND_W, band_t, wall_h + BOTTOM + band_t),
                     METAL_IDX,
                 )
             )
-            bevel_verts.extend(
+            metal.extend(
                 add_box(
                     bm,
-                    (bx, hy + BAND_T / <span class="n">2.0</span>, wall_z),
-                    (BAND_W, BAND_T, wall_h + <span class="n">0.01</span>),
+                    (
+                        bx,
+                        hy + band_t / <span class="n">2.0</span> + band_y_off,
+                        FOOT_H + (wall_h + BOTTOM) / <span class="n">2.0</span>,
+                    ),
+                    (BAND_W, band_t, wall_h + BOTTOM + band_t),
                     METAL_IDX,
                 )
             )
-            bevel_verts.extend(
+            metal.extend(
                 add_box(
                     bm,
-                    (bx, <span class="n">0.0</span>, FOOT_H + BAND_T / <span class="n">2.0</span>),
-                    (BAND_W, OUTER_D + <span class="n">2.0</span> * BAND_T, BAND_T),
+                    (bx, <span class="n">0.0</span>, FOOT_H - band_t / <span class="n">2.0</span> + <span class="n">0.002</span>),
+                    (BAND_W, OUTER_D - <span class="n">0.008</span>, band_t),
                     METAL_IDX,
                 )
             )
 
-        plate_w = <span class="n">0.12</span>
-        plate_h = <span class="n">0.13</span>
-        bevel_verts.extend(
-            add_box(
-                bm,
-                (<span class="n">0.0</span>, -hy - BAND_T - <span class="n">0.006</span>, FOOT_H + BOTTOM + CAVITY_H * <span class="n">0.55</span>),
-                (plate_w, <span class="n">0.014</span>, plate_h),
-                METAL_IDX,
-            )
-        )
-        bevel_verts.extend(
-            add_box(
-                bm,
-                (<span class="n">0.0</span>, -hy - BAND_T - <span class="n">0.018</span>, FOOT_H + BOTTOM + CAVITY_H * <span class="n">0.70</span>),
-                (<span class="n">0.036</span>, <span class="n">0.028</span>, <span class="n">0.022</span>),
-                METAL_IDX,
-            )
-        )
-
-        bracket = <span class="n">0.055</span>
-        thick = <span class="n">0.016</span>
         <span class="k">for</span> sxn <span class="k">in</span> (-<span class="n">1.0</span>, <span class="n">1.0</span>):
             <span class="k">for</span> syn <span class="k">in</span> (-<span class="n">1.0</span>, <span class="n">1.0</span>):
-                bevel_verts.extend(
+                metal.extend(
                     add_box(
                         bm,
                         (
-                            sxn * (hx + thick / <span class="n">2.0</span>),
-                            syn * (hy - bracket / <span class="n">2.0</span>),
+                            sxn * (hx - BRACKET / <span class="n">2.0</span> + <span class="n">0.004</span>),
+                            syn * (hy + IRON_T / <span class="n">2.0</span>),
                             wall_z,
                         ),
-                        (thick, bracket, wall_h - <span class="n">0.02</span>),
+                        (BRACKET - <span class="n">0.010</span>, IRON_T, wall_h - <span class="n">0.020</span>),
                         METAL_IDX,
                     )
                 )
-                bevel_verts.extend(
+                metal.extend(
                     add_box(
                         bm,
                         (
-                            sxn * (hx - bracket / <span class="n">2.0</span>),
-                            syn * (hy + thick / <span class="n">2.0</span>),
+                            sxn * (hx + IRON_T / <span class="n">2.0</span>),
+                            syn * (hy - BRACKET / <span class="n">2.0</span> + <span class="n">0.004</span>),
                             wall_z,
                         ),
-                        (bracket, thick, wall_h - <span class="n">0.02</span>),
+                        (IRON_T, BRACKET - <span class="n">0.010</span>, wall_h - <span class="n">0.020</span>),
                         METAL_IDX,
                     )
                 )
 
-        <span class="c"># Closed lid, then rotate around the back hinge so the front lifts.</span>
-        lid_z = body_top + LID_T / <span class="n">2.0</span>
-        lid_verts.extend(
+        plate_t = <span class="n">0.008</span>
+        metal.extend(
             add_box(
                 bm,
-                (<span class="n">0.0</span>, <span class="n">0.0</span>, lid_z),
-                (OUTER_W, OUTER_D, LID_T),
-                WOOD_IDX,
+                (<span class="n">0.0</span>, -hy - BAND_T - plate_t / <span class="n">2.0</span>, FOOT_H + BOTTOM + CAVITY_H * <span class="n">0.48</span>),
+                (<span class="n">0.11</span>, plate_t, <span class="n">0.12</span>),
+                METAL_IDX,
             )
         )
-        lid_verts.extend(
-            add_box(
-                bm,
-                (<span class="n">0.0</span>, -hy + LID_LIP / <span class="n">2.0</span>, body_top - LID_LIP / <span class="n">2.0</span> + <span class="n">0.004</span>),
-                (OUTER_W - <span class="n">0.02</span>, LID_LIP, LID_LIP),
-                WOOD_IDX,
+        st_y = -hy - BAND_T - plate_t - <span class="n">0.006</span>
+        st_z = FOOT_H + BOTTOM + CAVITY_H * <span class="n">0.58</span>
+        metal.extend(add_box(bm, (-<span class="n">0.012</span>, st_y, st_z), (<span class="n">0.008</span>, <span class="n">0.014</span>, <span class="n">0.022</span>), METAL_IDX))
+        metal.extend(add_box(bm, (<span class="n">0.012</span>, st_y, st_z), (<span class="n">0.008</span>, <span class="n">0.014</span>, <span class="n">0.022</span>), METAL_IDX))
+        metal.extend(add_box(bm, (<span class="n">0.0</span>, st_y, st_z + <span class="n">0.012</span>), (<span class="n">0.032</span>, <span class="n">0.014</span>, <span class="n">0.008</span>), METAL_IDX))
+
+        cz = body_top - math.sqrt(max(VAULT_R * VAULT_R - hy * hy, <span class="n">1e-6</span>))
+        a_front = math.atan2(-hy, body_top - cz)
+        a_back = math.atan2(hy, body_top - cz)
+        lid_wood.extend(
+            add_arc_slab(
+                bm, cz, a_front, a_back,
+                VAULT_R, VAULT_R + LID_T,
+                -hx + <span class="n">0.008</span>, hx - <span class="n">0.008</span>,
+                <span class="n">10</span>, WOOD_IDX,
             )
         )
-        lid_slat_w = (OUTER_W - <span class="n">0.05</span>) / N_LID
-        usable_l = lid_slat_w - <span class="n">0.006</span>
-        x0l = -hx + <span class="n">0.025</span> + usable_l / <span class="n">2.0</span>
-        <span class="k">for</span> i <span class="k">in</span> range(N_LID):
-            x = x0l + i * lid_slat_w
-            lid_verts.extend(
+
+        n_band_seg = <span class="n">8</span>
+        bspan = (a_back - a_front) / n_band_seg
+        r_band = VAULT_R + LID_T + BAND_T / <span class="n">2.0</span> + <span class="n">0.002</span>
+        <span class="k">for</span> bx <span class="k">in</span> band_xs:
+            <span class="k">for</span> i <span class="k">in</span> range(n_band_seg):
+                tmid = a_front + (i + <span class="n">0.5</span>) * bspan
+                y = r_band * math.sin(tmid)
+                z = cz + r_band * math.cos(tmid)
+                chord = r_band * bspan + <span class="n">0.003</span>
+                lid_metal.extend(
+                    add_box(
+                        bm, (bx, y, z),
+                        (BAND_W, chord, BAND_T),
+                        METAL_IDX, euler=(tmid, <span class="n">0.0</span>, <span class="n">0.0</span>),
+                    )
+                )
+            tmid = a_front
+            y = r_band * math.sin(tmid)
+            z = cz + r_band * math.cos(tmid)
+            lid_metal.extend(
                 add_box(
-                    bm,
-                    (x, <span class="n">0.0</span>, body_top + LID_T + SLAT_T / <span class="n">2.0</span>),
-                    (usable_l, OUTER_D - <span class="n">0.04</span>, SLAT_T),
-                    WOOD_IDX,
+                    bm, (bx, y - <span class="n">0.008</span>, z - <span class="n">0.006</span>),
+                    (BAND_W, BAND_T, LID_T + <span class="n">0.016</span>),
+                    METAL_IDX, euler=(tmid, <span class="n">0.0</span>, <span class="n">0.0</span>),
                 )
             )
-        <span class="k">for</span> bx <span class="k">in</span> band_xs:
-            lid_verts.extend(
+
+        tmid = a_front
+        r_hasp = VAULT_R + LID_T + <span class="n">0.006</span>
+        y = r_hasp * math.sin(tmid)
+        z = cz + r_hasp * math.cos(tmid)
+        lid_metal.extend(
+            add_box(
+                bm, (<span class="n">0.0</span>, y - <span class="n">0.018</span>, z - <span class="n">0.010</span>),
+                (<span class="n">0.038</span>, <span class="n">0.010</span>, <span class="n">0.055</span>),
+                METAL_IDX, euler=(tmid, <span class="n">0.0</span>, <span class="n">0.0</span>),
+            )
+        )
+
+        knuckle_verts = []
+        <span class="k">for</span> hx_i <span class="k">in</span> (-OUTER_W * <span class="n">0.28</span>, OUTER_W * <span class="n">0.28</span>):
+            metal.extend(
                 add_box(
-                    bm,
-                    (bx, <span class="n">0.0</span>, body_top + LID_T + SLAT_T + BAND_T / <span class="n">2.0</span>),
-                    (BAND_W, OUTER_D + <span class="n">2.0</span> * BAND_T, BAND_T),
-                    METAL_IDX,
+                    bm, (hx_i, hy + HINGE_R * <span class="n">0.15</span>, body_top),
+                    (<span class="n">0.050</span>, <span class="n">0.022</span>, <span class="n">0.022</span>), METAL_IDX,
                 )
             )
-            lid_verts.extend(
+            lid_metal.extend(
                 add_box(
-                    bm,
-                    (bx, -hy - BAND_T / <span class="n">2.0</span>, body_top + LID_T / <span class="n">2.0</span>),
-                    (BAND_W, BAND_T, LID_T + SLAT_T + <span class="n">0.01</span>),
-                    METAL_IDX,
+                    bm, (hx_i, hy - <span class="n">0.016</span>, body_top + <span class="n">0.006</span>),
+                    (<span class="n">0.036</span>, <span class="n">0.040</span>, <span class="n">0.008</span>), METAL_IDX,
                 )
             )
-        lid_verts.extend(
-            add_box(
-                bm,
-                (<span class="n">0.0</span>, -hy - BAND_T - <span class="n">0.006</span>, body_top + <span class="n">0.012</span>),
-                (<span class="n">0.055</span>, <span class="n">0.016</span>, <span class="n">0.028</span>),
-                METAL_IDX,
+            <span class="c"># Short lid knuckles over the barrels, not a spanning stile.</span>
+            <span class="c"># A full-width stile only has verts at the X ends, 8 cm from</span>
+            <span class="c"># the barrels, so a BVH join against it is a false gap.</span>
+            kv = add_box(
+                bm, (hx_i, hy + <span class="n">0.002</span>, body_top + <span class="n">0.012</span>),
+                (<span class="n">0.070</span>, <span class="n">0.028</span>, <span class="n">0.016</span>), WOOD_IDX,
             )
-        )
+            lid_wood.extend(kv)
+            knuckle_verts.extend(kv)
 
         hinge = Vector((<span class="n">0.0</span>, hy, body_top))
         rot = Euler((LID_ANGLE, <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> lid_verts:
+        <span class="k">for</span> v <span class="k">in</span> lid_wood + lid_metal:
             v.co = rot @ (v.co - hinge) + hinge
+        <span class="k">if</span> float_hinge:
+            <span class="c"># Lift knuckles off the barrels without swinging the vault</span>
+            <span class="c"># past the declared AABB (a shifted rotation pivot did).</span>
+            <span class="k">for</span> v <span class="k">in</span> knuckle_verts:
+                v.co.z += <span class="n">0.08</span>
 
+        bevel_verts = wood + knuckle_verts
         <span class="k">if</span> bevel_offset &gt; <span class="n">0.0</span>:
-            edges = list(
-                {e <span class="k">for</span> v <span class="k">in</span> (bevel_verts + lid_verts) <span class="k">for</span> e <span class="k">in</span> v.link_edges}
-            )
+            edges = list({e <span class="k">for</span> v <span class="k">in</span> bevel_verts <span class="k">for</span> e <span class="k">in</span> v.link_edges})
             bmesh.ops.bevel(
                 bm,
                 geom=edges,
@@ -688,6 +790,16 @@ <h2>Source</h2>
                 affect=<span class="s">&quot;EDGES&quot;</span>,
                 clamp_overlap=<span class="k">True</span>,
             )
+            <span class="k">for</span> v <span class="k">in</span> bevel_verts:
+                <span class="k">if</span> <span class="k">not</span> v.is_valid:
+                    <span class="k">continue</span>
+                <span class="k">for</span> f <span class="k">in</span> v.link_faces:
+                    f.material_index = WOOD_IDX
+        <span class="k">for</span> v <span class="k">in</span> metal + lid_metal:
+            <span class="k">if</span> <span class="k">not</span> v.is_valid:
+                <span class="k">continue</span>
+            <span class="k">for</span> f <span class="k">in</span> v.link_faces:
+                f.material_index = METAL_IDX
 
         xs = [v.co.x <span class="k">for</span> v <span class="k">in</span> bm.verts]
         ys = [v.co.y <span class="k">for</span> v <span class="k">in</span> bm.verts]
@@ -721,19 +833,37 @@ <h2>Source</h2>
     <span class="k">return</span> obj
 
 
-<span class="k">def</span> principled(name, color, metallic, roughness):
+<span class="k">def</span> principled(name, color, metallic, roughness, noise_scale=<span class="n">0.0</span>, wear=<span class="k">None</span>):
     mat = bpy.data.materials.new(name)
     mat.use_nodes = <span class="k">True</span>
-    bsdf = mat.node_tree.nodes[<span class="s">&quot;Principled BSDF&quot;</span>]
+    nt = mat.node_tree
+    bsdf = nt.nodes[<span class="s">&quot;Principled BSDF&quot;</span>]
     bsdf.inputs[<span class="s">&quot;Base Color&quot;</span>].default_value = color
     bsdf.inputs[<span class="s">&quot;Metallic&quot;</span>].default_value = metallic
     bsdf.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = roughness
+    <span class="k">if</span> noise_scale &gt; <span class="n">0.0</span> <span class="k">and</span> wear <span class="k">is</span> <span class="k">not</span> <span class="k">None</span>:
+        tex = nt.nodes.new(<span class="s">&quot;ShaderNodeTexNoise&quot;</span>)
+        tex.inputs[<span class="s">&quot;Scale&quot;</span>].default_value = noise_scale
+        tex.inputs[<span class="s">&quot;Detail&quot;</span>].default_value = <span class="n">8.0</span>
+        tex.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.55</span>
+        mix = nt.nodes.new(<span class="s">&quot;ShaderNodeMix&quot;</span>)
+        mix.data_type = <span class="s">&quot;RGBA&quot;</span>
+        mix.inputs[<span class="s">&quot;A&quot;</span>].default_value = color
+        mix.inputs[<span class="s">&quot;B&quot;</span>].default_value = wear
+        fac = mix.inputs.get(<span class="s">&quot;Factor&quot;</span>) <span class="k">or</span> mix.inputs.get(<span class="s">&quot;Fac&quot;</span>)
+        nt.links.new(tex.outputs[<span class="s">&quot;Fac&quot;</span>], fac)
+        nt.links.new(mix.outputs[<span class="s">&quot;Result&quot;</span>], bsdf.inputs[<span class="s">&quot;Base Color&quot;</span>])
+        rmix = nt.nodes.new(<span class="s">&quot;ShaderNodeMix&quot;</span>)
+        rmix.data_type = <span class="s">&quot;FLOAT&quot;</span>
+        rmix.inputs[<span class="s">&quot;A&quot;</span>].default_value = roughness
+        rmix.inputs[<span class="s">&quot;B&quot;</span>].default_value = min(<span class="n">1.0</span>, roughness + <span class="n">0.18</span>)
+        rfac = rmix.inputs.get(<span class="s">&quot;Factor&quot;</span>) <span class="k">or</span> rmix.inputs.get(<span class="s">&quot;Fac&quot;</span>)
+        nt.links.new(tex.outputs[<span class="s">&quot;Fac&quot;</span>], rfac)
+        nt.links.new(rmix.outputs[<span class="s">&quot;Result&quot;</span>], bsdf.inputs[<span class="s">&quot;Roughness&quot;</span>])
     <span class="k">return</span> mat
 
 
 <span class="k">def</span> assign_slots(obj, wood, metal):
-    <span class="c"># Do not materials.clear() — that resets polygon material_index to 0</span>
-    <span class="c"># on this Blender, which would drop metal faces onto wood.</span>
     mats = obj.data.materials
     wanted = (wood, metal)
     <span class="k">for</span> i, mat <span class="k">in</span> enumerate(wanted):
@@ -776,6 +906,260 @@ <h2>Source</h2>
     <span class="k">return</span> min(us), min(vs), max(us), max(vs), overlap, len(aabbs)
 
 
+<span class="k">def</span> face_area(me, poly):
+    idxs = poly.vertices
+    <span class="k">if</span> len(idxs) &lt; <span class="n">3</span>:
+        <span class="k">return</span> <span class="n">0.0</span>
+    v0 = me.vertices[idxs[<span class="n">0</span>]].co
+    area = <span class="n">0.0</span>
+    <span class="k">for</span> i <span class="k">in</span> range(<span class="n">1</span>, len(idxs) - <span class="n">1</span>):
+        vs = (me.vertices[idxs[i]].co, me.vertices[idxs[i + <span class="n">1</span>]].co)
+        area += (vs[<span class="n">0</span>] - v0).cross(vs[<span class="n">1</span>] - v0).length * <span class="n">0.5</span>
+    <span class="k">return</span> area
+
+
+<span class="k">def</span> hygiene_audit(me):
+    nv, ne, nf = len(me.vertices), len(me.edges), len(me.polygons)
+    ngons = sum(<span class="n">1</span> <span class="k">for</span> p <span class="k">in</span> me.polygons <span class="k">if</span> len(p.vertices) &gt; <span class="n">4</span>)
+    zero_area = sum(<span class="n">1</span> <span class="k">for</span> p <span class="k">in</span> me.polygons <span class="k">if</span> face_area(me, p) &lt;= AREA_EPS)
+    bm = bmesh.new()
+    <span class="k">try</span>:
+        bm.from_mesh(me)
+        bm.verts.ensure_lookup_table()
+        bm.edges.ensure_lookup_table()
+        loose_v = sum(<span class="n">1</span> <span class="k">for</span> v <span class="k">in</span> bm.verts <span class="k">if</span> len(v.link_edges) == <span class="n">0</span>)
+        loose_e = sum(<span class="n">1</span> <span class="k">for</span> e <span class="k">in</span> bm.edges <span class="k">if</span> len(e.link_faces) == <span class="n">0</span>)
+        nonman = sum(<span class="n">1</span> <span class="k">for</span> e <span class="k">in</span> bm.edges <span class="k">if</span> <span class="k">not</span> e.is_manifold)
+        ret = bmesh.ops.find_doubles(bm, verts=list(bm.verts), dist=DOUBLES_EPS)
+        doubles = len(ret.get(<span class="s">&quot;targetmap&quot;</span>) <span class="k">or</span> {})
+    <span class="k">finally</span>:
+        bm.free()
+    <span class="k">return</span> {
+        <span class="s">&quot;nv&quot;</span>: nv, <span class="s">&quot;ne&quot;</span>: ne, <span class="s">&quot;nf&quot;</span>: nf, <span class="s">&quot;ngons&quot;</span>: ngons,
+        <span class="s">&quot;loose_v&quot;</span>: loose_v, <span class="s">&quot;loose_e&quot;</span>: loose_e, <span class="s">&quot;nonman&quot;</span>: nonman,
+        <span class="s">&quot;zero_area&quot;</span>: zero_area, <span class="s">&quot;doubles&quot;</span>: doubles, <span class="s">&quot;euler&quot;</span>: nv - ne + nf,
+    }
+
+
+<span class="k">def</span> zfight_pairs(me):
+    data = [
+        (p.center.copy(), p.normal.copy(), frozenset(p.vertices))
+        <span class="k">for</span> p <span class="k">in</span> me.polygons
+    ]
+    eps2 = ZFIGHT_EPS * ZFIGHT_EPS
+    count = <span class="n">0</span>
+    <span class="k">for</span> i <span class="k">in</span> range(len(data)):
+        ci, ni, vi = data[i]
+        <span class="k">for</span> j <span class="k">in</span> range(i + <span class="n">1</span>, len(data)):
+            cj, nj, vj = data[j]
+            <span class="k">if</span> (cj - ci).length_squared &gt; eps2:
+                <span class="k">continue</span>
+            <span class="k">if</span> abs(ni.dot(nj)) &lt;= ZFIGHT_COS:
+                <span class="k">continue</span>
+            <span class="k">if</span> vi &amp; vj:
+                <span class="k">continue</span>
+            count += <span class="n">1</span>
+    <span class="k">return</span> count
+
+
+<span class="k">def</span> shells(me):
+    neighbors = [[] <span class="k">for</span> _ <span class="k">in</span> range(len(me.vertices))]
+    <span class="k">for</span> edge <span class="k">in</span> me.edges:
+        a, b = edge.vertices
+        neighbors[a].append(b)
+        neighbors[b].append(a)
+    seen = [<span class="k">False</span>] * len(me.vertices)
+    groups = []
+    <span class="k">for</span> start <span class="k">in</span> range(len(me.vertices)):
+        <span class="k">if</span> seen[start]:
+            <span class="k">continue</span>
+        seen[start] = <span class="k">True</span>
+        stack = [start]
+        group = []
+        <span class="k">while</span> stack:
+            current = stack.pop()
+            group.append(current)
+            <span class="k">for</span> nxt <span class="k">in</span> neighbors[current]:
+                <span class="k">if</span> <span class="k">not</span> seen[nxt]:
+                    seen[nxt] = <span class="k">True</span>
+                    stack.append(nxt)
+        groups.append(group)
+    <span class="k">return</span> groups
+
+
+<span class="k">def</span> shell_aabb(me, group):
+    pts = [me.vertices[i].co <span class="k">for</span> i <span class="k">in</span> group]
+    <span class="k">return</span> (
+        min(p.x <span class="k">for</span> p <span class="k">in</span> pts), min(p.y <span class="k">for</span> p <span class="k">in</span> pts), min(p.z <span class="k">for</span> p <span class="k">in</span> pts),
+        max(p.x <span class="k">for</span> p <span class="k">in</span> pts), max(p.y <span class="k">for</span> p <span class="k">in</span> pts), max(p.z <span class="k">for</span> p <span class="k">in</span> pts),
+    )
+
+
+<span class="k">def</span> mat_of(me, group):
+    member = set(group)
+    <span class="k">for</span> p <span class="k">in</span> me.polygons:
+        <span class="k">if</span> all(i <span class="k">in</span> member <span class="k">for</span> i <span class="k">in</span> p.vertices):
+            <span class="k">return</span> p.material_index
+    <span class="k">return</span> <span class="k">None</span>
+
+
+<span class="k">def</span> support_audit(me):
+    groups = shells(me)
+    feet = []
+    <span class="k">for</span> g <span class="k">in</span> groups:
+        <span class="k">if</span> mat_of(me, g) != WOOD_IDX:
+            <span class="k">continue</span>
+        a = shell_aabb(me, g)
+        dx, dy, dz = a[<span class="n">3</span>] - a[<span class="n">0</span>], a[<span class="n">4</span>] - a[<span class="n">1</span>], a[<span class="n">5</span>] - a[<span class="n">2</span>]
+        <span class="k">if</span> a[<span class="n">5</span>] &lt; <span class="n">0.10</span> <span class="k">and</span> dx &lt; <span class="n">0.12</span> <span class="k">and</span> dy &lt; <span class="n">0.12</span> <span class="k">and</span> dz &gt; <span class="n">0.03</span>:
+            feet.append(a)
+    foot_z = min((a[<span class="n">2</span>] <span class="k">for</span> a <span class="k">in</span> feet), default=<span class="n">99.0</span>)
+    <span class="k">return</span> {<span class="s">&quot;feet&quot;</span>: len(feet), <span class="s">&quot;foot_z&quot;</span>: foot_z}
+
+
+<span class="k">def</span> body_audit(me):
+    groups = shells(me)
+    best = <span class="k">None</span>
+    best_area = -<span class="n">1.0</span>
+    <span class="k">for</span> g <span class="k">in</span> groups:
+        <span class="k">if</span> mat_of(me, g) != WOOD_IDX:
+            <span class="k">continue</span>
+        a = shell_aabb(me, g)
+        dx, dy = a[<span class="n">3</span>] - a[<span class="n">0</span>], a[<span class="n">4</span>] - a[<span class="n">1</span>]
+        <span class="k">if</span> dx &gt; <span class="n">0.50</span> <span class="k">and</span> dy &gt; <span class="n">0.30</span> <span class="k">and</span> a[<span class="n">2</span>] &lt; <span class="n">0.12</span>:
+            area = dx * dy
+            <span class="k">if</span> area &gt; best_area:
+                best_area = area
+                best = a
+    <span class="k">if</span> best <span class="k">is</span> <span class="k">None</span>:
+        <span class="k">return</span> {<span class="s">&quot;w&quot;</span>: <span class="n">0.0</span>, <span class="s">&quot;d&quot;</span>: <span class="n">0.0</span>}
+    <span class="k">return</span> {<span class="s">&quot;w&quot;</span>: best[<span class="n">3</span>] - best[<span class="n">0</span>], <span class="s">&quot;d&quot;</span>: best[<span class="n">4</span>] - best[<span class="n">1</span>]}
+
+
+<span class="k">def</span> hinge_join(me):
+    <span class="s">&quot;&quot;&quot;Gap from lid knuckles to the hinge barrels.
+
+    Barrels are compact metal at the back rim. Knuckles are compact wood
+    at the same station. Lock-plate staples, lid-band caps, and the
+    hasp must not enter this set — they sit on the front of the chest.
+    &quot;&quot;&quot;</span>
+    groups = shells(me)
+    hinges = []
+    lid_wood = []
+    <span class="k">for</span> g <span class="k">in</span> groups:
+        a = shell_aabb(me, g)
+        m = mat_of(me, g)
+        dx, dy, dz = a[<span class="n">3</span>] - a[<span class="n">0</span>], a[<span class="n">4</span>] - a[<span class="n">1</span>], a[<span class="n">5</span>] - a[<span class="n">2</span>]
+        back_rim = a[<span class="n">1</span>] &gt; <span class="n">0.15</span> <span class="k">and</span> a[<span class="n">2</span>] &gt; <span class="n">0.30</span>
+        <span class="k">if</span> (
+            m == METAL_IDX <span class="k">and</span> back_rim
+            <span class="k">and</span> <span class="n">0.03</span> &lt; dx &lt; <span class="n">0.08</span> <span class="k">and</span> <span class="n">0.015</span> &lt; dy &lt; <span class="n">0.040</span> <span class="k">and</span> <span class="n">0.015</span> &lt; dz &lt; <span class="n">0.040</span>
+        ):
+            hinges.append(g)
+        <span class="k">if</span> (
+            m == WOOD_IDX <span class="k">and</span> back_rim
+            <span class="k">and</span> <span class="n">0.04</span> &lt; dx &lt; <span class="n">0.12</span> <span class="k">and</span> dy &lt; <span class="n">0.05</span> <span class="k">and</span> dz &lt; <span class="n">0.04</span>
+        ):
+            lid_wood.append(g)
+    <span class="k">if</span> <span class="k">not</span> hinges <span class="k">or</span> <span class="k">not</span> lid_wood:
+        <span class="k">return</span> <span class="n">99.0</span>
+    bm_h = bmesh.new()
+    <span class="k">try</span>:
+        bm_h.from_mesh(me)
+        keep = set()
+        <span class="k">for</span> g <span class="k">in</span> hinges:
+            keep.update(g)
+        drop = [
+            f <span class="k">for</span> f <span class="k">in</span> bm_h.faces
+            <span class="k">if</span> <span class="k">not</span> all(v.index <span class="k">in</span> keep <span class="k">for</span> v <span class="k">in</span> f.verts)
+        ]
+        <span class="k">if</span> drop:
+            bmesh.ops.delete(bm_h, geom=drop, context=<span class="s">&quot;FACES&quot;</span>)
+        <span class="k">if</span> <span class="k">not</span> bm_h.faces:
+            <span class="k">return</span> <span class="n">99.0</span>
+        tree = BVHTree.FromBMesh(bm_h)
+        best = <span class="n">99.0</span>
+        <span class="k">for</span> g <span class="k">in</span> lid_wood:
+            <span class="k">for</span> i <span class="k">in</span> g:
+                hit = tree.find_nearest(me.vertices[i].co)
+                <span class="k">if</span> hit[<span class="n">0</span>] <span class="k">is</span> <span class="k">None</span>:
+                    <span class="k">continue</span>
+                best = min(best, hit[<span class="n">3</span>])
+        <span class="k">return</span> best
+    <span class="k">finally</span>:
+        bm_h.free()
+
+
+<span class="k">def</span> band_wall_gap(me):
+    <span class="s">&quot;&quot;&quot;Worst gap from a vertical iron band to wood.
+
+    Overlap counts as 0. ``--narrow-bands`` floats the straps off the
+    slats so this goes positive.
+    &quot;&quot;&quot;</span>
+    groups = shells(me)
+    bands = []
+    <span class="k">for</span> g <span class="k">in</span> groups:
+        <span class="k">if</span> mat_of(me, g) != METAL_IDX:
+            <span class="k">continue</span>
+        a = shell_aabb(me, g)
+        dx, dy, dz = a[<span class="n">3</span>] - a[<span class="n">0</span>], a[<span class="n">4</span>] - a[<span class="n">1</span>], a[<span class="n">5</span>] - a[<span class="n">2</span>]
+        <span class="k">if</span> dz &gt; <span class="n">0.15</span> <span class="k">and</span> dx &lt; <span class="n">0.10</span> <span class="k">and</span> dy &lt; <span class="n">0.08</span>:
+            bands.append(g)
+    <span class="k">if</span> <span class="k">not</span> bands:
+        <span class="k">return</span> <span class="n">99.0</span>
+    bm_wood = bmesh.new()
+    <span class="k">try</span>:
+        bm_wood.from_mesh(me)
+        drop = [f <span class="k">for</span> f <span class="k">in</span> bm_wood.faces <span class="k">if</span> f.material_index != WOOD_IDX]
+        <span class="k">if</span> drop:
+            bmesh.ops.delete(bm_wood, geom=drop, context=<span class="s">&quot;FACES&quot;</span>)
+        <span class="k">if</span> <span class="k">not</span> bm_wood.faces:
+            <span class="k">return</span> <span class="n">99.0</span>
+        tree_wood = BVHTree.FromBMesh(bm_wood)
+        worst = <span class="n">0.0</span>
+        <span class="k">for</span> g <span class="k">in</span> bands:
+            bm_s = bmesh.new()
+            <span class="k">try</span>:
+                bm_s.from_mesh(me)
+                member = set(g)
+                drop_s = [
+                    f <span class="k">for</span> f <span class="k">in</span> bm_s.faces
+                    <span class="k">if</span> <span class="k">not</span> all(v.index <span class="k">in</span> member <span class="k">for</span> v <span class="k">in</span> f.verts)
+                ]
+                <span class="k">if</span> drop_s:
+                    bmesh.ops.delete(bm_s, geom=drop_s, context=<span class="s">&quot;FACES&quot;</span>)
+                <span class="k">if</span> <span class="k">not</span> bm_s.faces:
+                    worst = max(worst, <span class="n">99.0</span>)
+                    <span class="k">continue</span>
+                tree_s = BVHTree.FromBMesh(bm_s)
+                <span class="k">if</span> tree_wood.overlap(tree_s):
+                    <span class="k">continue</span>
+                best = <span class="n">99.0</span>
+                <span class="k">for</span> i <span class="k">in</span> g:
+                    hit = tree_wood.find_nearest(me.vertices[i].co)
+                    <span class="k">if</span> hit[<span class="n">0</span>] <span class="k">is</span> <span class="k">None</span>:
+                        <span class="k">continue</span>
+                    best = min(best, hit[<span class="n">3</span>])
+                <span class="k">if</span> best &gt; worst:
+                    worst = best
+            <span class="k">finally</span>:
+                bm_s.free()
+        <span class="k">return</span> worst
+    <span class="k">finally</span>:
+        bm_wood.free()
+
+
+<span class="k">def</span> add_stray_vert(me):
+    bm = bmesh.new()
+    <span class="k">try</span>:
+        bm.from_mesh(me)
+        bm.verts.new((<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.40</span>))
+        bm.to_mesh(me)
+        me.update()
+    <span class="k">finally</span>:
+        bm.free()
+
+
 <span class="k">def</span> make_lod(obj, name, ratio, skip_decimate):
     mesh = obj.data.copy()
     lod = bpy.data.objects.new(name, mesh)
@@ -789,7 +1173,6 @@ <h2>Source</h2>
 
 
 <span class="k">def</span> convex_hull_collider(obj, name):
-    <span class="c"># Duplicated from snippets/convex_hull_collider.py (not a package).</span>
     mesh = bpy.data.meshes.new(name)
     bm = bmesh.new()
     <span class="k">try</span>:
@@ -812,7 +1195,6 @@ <h2>Source</h2>
 
 
 <span class="k">def</span> setup_bake_image(obj, target_mat, size=BAKE_RES):
-    <span class="c"># Adapted from snippets/setup_bake_target_image.py — do not replace slots.</span>
     <span class="k">if</span> <span class="k">not</span> obj.data.uv_layers:
         <span class="k">return</span> <span class="k">None</span>, <span class="k">None</span>
     img = bpy.data.images.new(<span class="s">&quot;ChestNrm&quot;</span>, size, size, alpha=<span class="k">True</span>, float_buffer=<span class="k">False</span>)
@@ -827,7 +1209,6 @@ <h2>Source</h2>
 
 
 <span class="k">def</span> bake_normal(high, low):
-    <span class="c"># Duplicated from snippets/bake_normal_high_to_low.py (not a package).</span>
     scene = bpy.context.scene
     scene.render.engine = <span class="s">&quot;CYCLES&quot;</span>
     scene.cycles.device = <span class="s">&quot;CPU&quot;</span>
@@ -852,7 +1233,6 @@ <h2>Source</h2>
 
 
 <span class="k">def</span> export_unity(path, objects):
-    <span class="c"># Duplicated from snippets/export_preset_unity.py (not a package).</span>
     <span class="k">for</span> ob <span class="k">in</span> bpy.context.view_layer.objects:
         ob.select_set(<span class="k">False</span>)
     <span class="k">for</span> ob <span class="k">in</span> objects:
@@ -868,14 +1248,33 @@ <h2>Source</h2>
     )
 
 
-<span class="k">def</span> check(skip_decimate):
+<span class="k">def</span> check(
+    skip_decimate, lift_z=<span class="k">False</span>, stray_vert=<span class="k">False</span>,
+    short_legs=<span class="k">False</span>, float_hinge=<span class="k">False</span>, narrow_bands=<span class="k">False</span>,
+):
     bpy.ops.wm.read_factory_settings(use_empty=<span class="k">True</span>)
-    low = build_chest_mesh(<span class="s">&quot;ChestLow&quot;</span>, bevel_offset=<span class="n">0.008</span>, bevel_segments=<span class="n">2</span>)
-    high = build_chest_mesh(<span class="s">&quot;ChestHigh&quot;</span>, bevel_offset=<span class="n">0.008</span>, bevel_segments=<span class="n">4</span>)
-    wood = principled(<span class="s">&quot;ChestWood&quot;</span>, (<span class="n">0.42</span>, <span class="n">0.20</span>, <span class="n">0.07</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.52</span>)
-    metal = principled(<span class="s">&quot;ChestMetal&quot;</span>, (<span class="n">0.22</span>, <span class="n">0.23</span>, <span class="n">0.26</span>, <span class="n">1.0</span>), <span class="n">1.0</span>, <span class="n">0.30</span>)
+    flags = dict(
+        short_legs=short_legs, float_hinge=float_hinge, narrow_bands=narrow_bands,
+    )
+    low = build_chest_mesh(<span class="s">&quot;ChestLow&quot;</span>, <span class="n">0.003</span>, <span class="n">2</span>, **flags)
+    high = build_chest_mesh(<span class="s">&quot;ChestHigh&quot;</span>, <span class="n">0.003</span>, <span class="n">4</span>, **flags)
+    wood = principled(
+        <span class="s">&quot;ChestWood&quot;</span>, (<span class="n">0.40</span>, <span class="n">0.18</span>, <span class="n">0.06</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.54</span>,
+        noise_scale=<span class="n">6.5</span>, wear=(<span class="n">0.22</span>, <span class="n">0.10</span>, <span class="n">0.04</span>, <span class="n">1.0</span>),
+    )
+    metal = principled(
+        <span class="s">&quot;ChestMetal&quot;</span>, (<span class="n">0.18</span>, <span class="n">0.19</span>, <span class="n">0.22</span>, <span class="n">1.0</span>), <span class="n">1.0</span>, <span class="n">0.32</span>,
+        noise_scale=<span class="n">5.0</span>, wear=(<span class="n">0.08</span>, <span class="n">0.08</span>, <span class="n">0.09</span>, <span class="n">1.0</span>),
+    )
     assign_slots(low, wood, metal)
     assign_slots(high, wood, metal)
+    <span class="k">if</span> stray_vert:
+        add_stray_vert(low.data)
+    <span class="k">if</span> lift_z:
+        <span class="k">for</span> v <span class="k">in</span> low.data.vertices:
+            v.co.z += LIFT_Z
+        low.data.update()
+        bpy.context.view_layer.update()
 
     <span class="k">if</span> low.data <span class="k">is</span> <span class="k">None</span> <span class="k">or</span> len(low.data.polygons) &lt; <span class="n">6</span>:
         <span class="k">return</span> fail(<span class="s">&quot;chest 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>
@@ -907,9 +1306,7 @@ <h2>Source</h2>
     r1 = lod1_tris / base_tris <span class="k">if</span> base_tris <span class="k">else</span> <span class="n">0.0</span>
     r2 = lod2_tris / base_tris <span class="k">if</span> base_tris <span class="k">else</span> <span class="n">0.0</span>
 
-    collider_src = build_chest_mesh(
-        <span class="s">&quot;ChestColSrc&quot;</span>, bevel_offset=<span class="n">0.0</span>, bevel_segments=<span class="n">1</span>
-    )
+    collider_src = build_chest_mesh(<span class="s">&quot;ChestColSrc&quot;</span>, <span class="n">0.0</span>, <span class="n">1</span>, **flags)
     collider = convex_hull_collider(collider_src, <span class="s">&quot;ChestCollider&quot;</span>)
     bpy.data.objects.remove(collider_src, do_unlink=<span class="k">True</span>)
     col_tris = triangle_count(collider.data)
@@ -923,9 +1320,14 @@ <h2>Source</h2>
     export_unity(export_path, [low, collider])
     export_size = os.path.getsize(export_path) <span class="k">if</span> os.path.isfile(export_path) <span class="k">else</span> <span class="n">0</span>
 
-    print(
-        <span class="s">f&quot;</span><span class="s">blender=</span>{tuple(bpy.app.version)}<span class="s"> skip_decimate=</span>{skip_decimate}<span class="s">&quot;</span>
-    )
+    hyg = hygiene_audit(low.data)
+    zf = zfight_pairs(low.data)
+    sup = support_audit(low.data)
+    body = body_audit(low.data)
+    hj = hinge_join(low.data)
+    bg = band_wall_gap(low.data)
+
+    print(<span class="s">f&quot;</span><span class="s">blender=</span>{tuple(bpy.app.version)}<span class="s"> skip_decimate=</span>{skip_decimate}<span class="s">&quot;</span>)
     print(
         <span class="s">f&quot;</span><span class="s">measured base_tris=</span>{base_tris}<span class="s"> lod1_tris=</span>{lod1_tris}<span class="s"> </span><span class="s">&quot;</span>
         <span class="s">f&quot;</span><span class="s">lod2_tris=</span>{lod2_tris}<span class="s"> r1=</span>{r1:<span class="s">.4f</span>}<span class="s"> r2=</span>{r2:<span class="s">.4f</span>}<span class="s">&quot;</span>
@@ -942,6 +1344,16 @@ <h2>Source</h2>
         <span class="s">f&quot;</span><span class="s">measured collider_tris=</span>{col_tris}<span class="s"> bake=</span>{bake_result}<span class="s"> </span><span class="s">&quot;</span>
         <span class="s">f&quot;</span><span class="s">bake_has_data=</span>{img.has_data}<span class="s"> export_bytes=</span>{export_size}<span class="s">&quot;</span>
     )
+    print(
+        <span class="s">f&quot;</span><span class="s">measured hygiene loose_v=</span>{hyg[<span class="s">&#x27;loose_v&#x27;</span>]}<span class="s"> loose_e=</span>{hyg[<span class="s">&#x27;loose_e&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">nonman=</span>{hyg[<span class="s">&#x27;nonman&#x27;</span>]}<span class="s"> zero_area=</span>{hyg[<span class="s">&#x27;zero_area&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">doubles=</span>{hyg[<span class="s">&#x27;doubles&#x27;</span>]}<span class="s"> ngons=</span>{hyg[<span class="s">&#x27;ngons&#x27;</span>]}<span class="s"> zfight=</span>{zf}<span class="s">&quot;</span>
+    )
+    print(
+        <span class="s">f&quot;</span><span class="s">measured supports feet=</span>{sup[<span class="s">&#x27;feet&#x27;</span>]}<span class="s"> foot_z=</span>{sup[<span class="s">&#x27;foot_z&#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">body_w=</span>{body[<span class="s">&#x27;w&#x27;</span>]:<span class="s">.4f</span>}<span class="s"> body_d=</span>{body[<span class="s">&#x27;d&#x27;</span>]:<span class="s">.4f</span>}<span class="s"> </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">hinge_join=</span>{hj:<span class="s">.5f</span>}<span class="s"> band_gap=</span>{bg:<span class="s">.5f</span>}<span class="s">&quot;</span>
+    )
 
     <span class="k">if</span> <span class="k">not</span> (BASE_TRIS_MIN &lt;= base_tris &lt;= BASE_TRIS_MAX):
         <span class="k">return</span> fail(
@@ -958,6 +1370,11 @@ <h2>Source</h2>
             <span class="s">f&quot;</span><span class="s">metal faces </span>{idx_counts.get(METAL_IDX, <span class="n">0</span>)}<span class="s"> &lt; </span>{METAL_FACES_MIN}<span class="s">&quot;</span>,
             <span class="n">5</span>,
         ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+    <span class="k">if</span> idx_counts.get(WOOD_IDX, <span class="n">0</span>) &lt; WOOD_FACES_MIN:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">wood faces </span>{idx_counts.get(WOOD_IDX, <span class="n">0</span>)}<span class="s"> &lt; </span>{WOOD_FACES_MIN}<span class="s">&quot;</span>,
+            <span class="n">5</span>,
+        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
     <span class="k">if</span> u0 &lt; -UV_EPS <span class="k">or</span> v0 &lt; -UV_EPS <span class="k">or</span> u1 &gt; <span class="n">1.0</span> + UV_EPS <span class="k">or</span> v1 &gt; <span class="n">1.0</span> + UV_EPS:
         <span class="k">return</span> fail(
             <span class="s">f&quot;</span><span class="s">UVs outside 0..1: (</span>{u0:<span class="s">.4f</span>}<span class="s">,</span>{v0:<span class="s">.4f</span>}<span class="s">)-(</span>{u1:<span class="s">.4f</span>}<span class="s">,</span>{v1:<span class="s">.4f</span>}<span class="s">)</span><span class="s">&quot;</span>,
@@ -1001,6 +1418,50 @@ <h2>Source</h2>
         ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
     <span class="k">if</span> export_size &lt;= <span class="n">0</span>:
         <span class="k">return</span> fail(<span class="s">&quot;export file missing or empty&quot;</span>, <span class="n">13</span>), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+    <span class="k">if</span> (
+        hyg[<span class="s">&quot;loose_v&quot;</span>] <span class="k">or</span> hyg[<span class="s">&quot;loose_e&quot;</span>] <span class="k">or</span> hyg[<span class="s">&quot;nonman&quot;</span>]
+        <span class="k">or</span> hyg[<span class="s">&quot;zero_area&quot;</span>] <span class="k">or</span> hyg[<span class="s">&quot;doubles&quot;</span>] <span class="k">or</span> hyg[<span class="s">&quot;ngons&quot;</span>] <span class="k">or</span> zf
+    ):
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">hygiene loose_v=</span>{hyg[<span class="s">&#x27;loose_v&#x27;</span>]}<span class="s"> loose_e=</span>{hyg[<span class="s">&#x27;loose_e&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">f&quot;</span><span class="s">nonman=</span>{hyg[<span class="s">&#x27;nonman&#x27;</span>]}<span class="s"> zero_area=</span>{hyg[<span class="s">&#x27;zero_area&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">f&quot;</span><span class="s">doubles=</span>{hyg[<span class="s">&#x27;doubles&#x27;</span>]}<span class="s"> ngons=</span>{hyg[<span class="s">&#x27;ngons&#x27;</span>]}<span class="s"> zfight=</span>{zf}<span class="s">&quot;</span>,
+            <span class="n">15</span>,
+        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+    <span class="k">if</span> abs(bb[<span class="n">2</span>]) &gt; ZMIN_EPS:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">zmin </span>{bb[<span class="n">2</span>]:<span class="s">.6f</span>}<span class="s"> not within </span>{ZMIN_EPS}<span class="s"> of 0 </span><span class="s">&quot;</span>
+            <span class="s">&quot;(--lift-z is the designed fail)&quot;</span>,
+            <span class="n">16</span>,
+        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+    <span class="k">if</span> sup[<span class="s">&quot;feet&quot;</span>] &lt; <span class="n">4</span> <span class="k">or</span> sup[<span class="s">&quot;foot_z&quot;</span>] &gt; FOOT_Z_MAX:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">foot supports </span>{sup[<span class="s">&#x27;feet&#x27;</span>]}<span class="s"> foot_z=</span>{sup[<span class="s">&#x27;foot_z&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">&quot;(--short-legs 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> hj &gt; HINGE_JOIN:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">lid-hinge gap </span>{hj:<span class="s">.5f</span>}<span class="s"> &gt; </span>{HINGE_JOIN}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">&quot;(--float-hinge is the designed fail)&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> bg &gt; BAND_SEAT:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">band-wall gap </span>{bg:<span class="s">.5f</span>}<span class="s"> &gt; </span>{BAND_SEAT}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">&quot;(--narrow-bands is the designed fail)&quot;</span>,
+            <span class="n">18</span>,
+        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+    <span class="k">if</span> abs(body[<span class="s">&quot;w&quot;</span>] - BODY_W) &gt; BODY_W_TOL:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">body width </span>{body[<span class="s">&#x27;w&#x27;</span>]:<span class="s">.4f</span>}<span class="s"> off </span>{BODY_W}<span class="s">&quot;</span>,
+            <span class="n">19</span>,
+        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+    <span class="k">if</span> abs(body[<span class="s">&quot;d&quot;</span>] - BODY_D) &gt; BODY_D_TOL:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">body depth </span>{body[<span class="s">&#x27;d&#x27;</span>]:<span class="s">.4f</span>}<span class="s"> off </span>{BODY_D}<span class="s">&quot;</span>,
+            <span class="n">19</span>,
+        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
     <span class="k">return</span> <span class="n">0</span>, low, high, wood, tex, collider
 
 
@@ -1068,10 +1529,10 @@ <h2>Source</h2>
     cam_data = bpy.data.cameras.new(<span class="s">&quot;Cam&quot;</span>)
     cam_data.lens = <span class="n">50.0</span>
     cam = bpy.data.objects.new(<span class="s">&quot;Cam&quot;</span>, cam_data)
-    cam.location = (<span class="n">1.54</span>, -<span class="n">2.16</span>, <span class="n">1.37</span>)
+    cam.location = (<span class="n">1.62</span>, -<span class="n">2.22</span>, <span class="n">1.42</span>)
     scene.collection.objects.link(cam)
     aim = bpy.data.objects.new(<span class="s">&quot;Aim&quot;</span>, <span class="k">None</span>)
-    aim.location = (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.34</span>)
+    aim.location = (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.36</span>)
     scene.collection.objects.link(aim)
     con = cam.constraints.new(<span class="s">&quot;TRACK_TO&quot;</span>)
     con.target = aim
@@ -1114,14 +1575,22 @@ <h2>Source</h2>
     p = argparse.ArgumentParser()
     p.add_argument(<span class="s">&quot;--output&quot;</span>, default=<span class="k">None</span>)
     p.add_argument(<span class="s">&quot;--engine&quot;</span>, default=<span class="s">&quot;eevee&quot;</span>, choices=(<span class="s">&quot;eevee&quot;</span>, <span class="s">&quot;cycles&quot;</span>))
-    p.add_argument(
-        <span class="s">&quot;--skip-decimate&quot;</span>,
-        action=<span class="s">&quot;store_true&quot;</span>,
-        help=<span class="s">&quot;falsification: skip the LOD DECIMATE stage&quot;</span>,
-    )
+    p.add_argument(<span class="s">&quot;--skip-decimate&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--lift-z&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--stray-vert&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--short-legs&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--float-hinge&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--narrow-bands&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
     args = p.parse_args(argv)
 
-    code, low, _high, wood, tex, _col = check(args.skip_decimate)
+    code, low, _high, wood, tex, _col = check(
+        args.skip_decimate,
+        lift_z=args.lift_z,
+        stray_vert=args.stray_vert,
+        short_legs=args.short_legs,
+        float_hinge=args.float_hinge,
+        narrow_bands=args.narrow_bands,
+    )
     <span class="k">if</span> code:
         <span class="k">return</span> code
     <span class="k">if</span> args.output:
diff --git a/showcase/README.md b/showcase/README.md
index c98a84b..2a4395a 100644
--- a/showcase/README.md
+++ b/showcase/README.md
@@ -52,7 +52,9 @@ entry in `showcase/gallery.json`, and a rendered still.
   Multi-body props do **not** require Euler characteristic 2 — that is a
   single-shell contract. Pairs of parts meant to touch assert a BVH
   surface gap below a named epsilon (vert-vert is the wrong metric for
-  thin straps and collars).
+  thin straps and collars). A spanning board whose only vertices sit at
+  the far ends will report a false gap to a mid-span knuckle; put a
+  local shell at the joint station, or measure a slice there.
 - **Named supports (exit 16).** AABB `zmin` is necessary but not
   sufficient on a multi-support prop: a wheel, a sled floor, or one
   planted foot can ground the box while the other feet float. Split the
diff --git a/showcase/gallery.json b/showcase/gallery.json
index 2310696..9a24950 100644
--- a/showcase/gallery.json
+++ b/showcase/gallery.json
@@ -80,8 +80,8 @@
     {
       "name": "treasure-chest",
       "dir": "showcase/treasure-chest",
-      "teaches": "A procedural slatted treasure chest through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.",
-      "witnessesFix": "Recomputed: 5724 tris, two materials with 180 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.776×0.549×0.631 m, LOD ratios in band, convex collider 138 tris, non-empty glTF. --skip-decimate exits 9 on the LOD1 ratio budget.",
+      "teaches": "A procedural iron-bound chest with a lofted barrel-vault lid, U-wrap bands, and hinge knuckles through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.",
+      "witnessesFix": "Recomputed: 3852 tris, two materials with 1608 wood and 318 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.764×0.542×0.691 m, LOD ratios in band, convex collider 176 tris, non-empty glTF. Hygiene all zero, four feet at zmin 0, lid-knuckle to hinge barrel 7 mm, band-wall gap 0. --float-hinge exits 17 on the hinge join; --narrow-bands exits 18 on the band seat.",
       "hero": "docs/gallery/assets/treasure-chest-hero.webp",
       "preview": "showcase/treasure-chest/preview.webp",
       "tags": [
@@ -272,8 +272,8 @@
     {
       "name": "tavern-stool",
       "dir": "showcase/tavern-stool",
-      "teaches": "A procedural tavern stool with a round seat, turned splayed legs, stretchers, and iron ferrules through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.",
-      "witnessesFix": "Recomputed: 5396 tris, two materials with 2542 wood and 40 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.309×0.309×0.467 m, LOD ratios in band, convex collider 96 tris, non-empty glTF. --skip-decimate exits 9 on the LOD1 ratio budget.",
+      "teaches": "A procedural tavern stool with a lathed seat, turned splayed legs, tenoned stretchers, and iron ferrule cups through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.",
+      "witnessesFix": "Recomputed: 2528 tris, two materials with 1168 wood and 256 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.340×0.340×0.470 m, LOD ratios in band, convex collider 396 tris, non-empty glTF. Hygiene all zero, four ferrule cups at zmin 0, stretcher-leg gap 0, ferrule clearance −1.25 mm. --float-stretchers exits 17 on the stretcher join; --pipe-ferrule exits 18 on the ferrule bite band.",
       "hero": "docs/gallery/assets/tavern-stool-hero.webp",
       "preview": "showcase/tavern-stool/preview.webp",
       "tags": [
diff --git a/showcase/tavern-stool/README.md b/showcase/tavern-stool/README.md
index 6833b2b..409b254 100644
--- a/showcase/tavern-stool/README.md
+++ b/showcase/tavern-stool/README.md
@@ -1,9 +1,14 @@
 # Tavern stool
 
-A showcase piece, not an example. Procedural tavern stool (round seat,
-turned splayed legs, stretchers, iron ferrules) 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 tavern stool (lathed round
+seat, turned splayed legs, tenoned stretchers, iron ferrule cups) then
+the shipped pipeline: unique-cell UVs, Cycles high-to-low normal bake,
+LOD chain, convex collider, Unity glTF export.
+
+Legs are one loft per leg, not stacked cones. Ferrules are vertical cups
+the foot drops into; wood ends above the cup so a splayed cone does not
+sawtooth through the wall. Stretchers are classified as compact rails,
+not the seat disc.
 
 It asserts **budget conformance** of the generated result. It does not
 witness an API contract. "It rendered without error" is not a check.
@@ -21,39 +26,78 @@ materials, UVs, evaluated LOD, collider, or export file.
 
 | Axis | Declared | Measured (4.5.11 / 5.1.2 / 5.2.1) |
 | --- | --- | --- |
-| Base triangles | 5250–5550 | 5396 / 5396 / 5396 |
+| Base triangles | 2300–3200 | 2528 / 2528 / 2528 |
 | LOD1 ratio | 0.32–0.62 of base | 0.5000 / 0.5000 / 0.5000 |
-| LOD2 ratio | 0.10–0.35 of base | 0.2198 / 0.2198 / 0.2198 |
-| Materials | exactly 2 distinct, ≥24 wood, ≥16 metal | 2 slots, 2542 wood, 40 metal |
+| LOD2 ratio | 0.10–0.35 of base | 0.2199 / 0.2199 / 0.2199 |
+| Materials | exactly 2 distinct; ≥200 wood, ≥48 metal faces | 2 slots; 1168 / 256 |
 | UVs | in `0..1`, AABB overlap ≤ 1e-5 | in range, overlap 0 |
-| Outer AABB | (0.309, 0.309, 0.467) m ± 0.01 | (0.3093, 0.3093, 0.4670), zmin 0.002 |
-| Collider tris | ≤ 140 | 96 |
-| Export | written, size > 0 | 380604 / 380604 / 380588 bytes |
+| Outer AABB | (0.341, 0.341, 0.470) m ± 0.015 | (0.3400, 0.3400, 0.4700), zmin 0 |
+| Collider tris | ≤ 640 | 396 |
+| Export | written, size > 0 | 215912 / 215912 / 215900 bytes |
+
+### Hygiene
+
+Recomputed from the generated mesh, not asserted about the script.
 
-DECIMATE COLLAPSE triangle counts are **not** identical across series in
-general — the gate is a ratio band, not an exact count. On this mesh LOD2
-matched across 4.5.11 / 5.1.2 / 5.2.1. 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.
+| Axis | Declared | Measured (all three) |
+| --- | --- | --- |
+| Non-manifold edges | 0 | 0 |
+| Loose verts / edges | 0 / 0 | 0 / 0 |
+| Doubles merged at 1e-5 | 0 | 0 |
+| Zero-area faces | 0 | 0 |
+| N-gons | 0 | 0 |
+| Coplanar disjoint face pairs | 0 | 0 |
+| Grounded: `zmin` | within 1e-4 of 0 | 0.0000 |
+| Named supports: 4 ferrule cups | each `zmin` ≤ 1e-3 | 4, cup_z 0.00000 |
+| Seat | 0.340 m dia × 0.470 m high ± 0.02 | 0.3400 × 0.4700 |
+
+### Joint fit and seat
 
-`--skip-decimate` skips the LOD DECIMATE stage so LOD1 ratio is 1.0 and
-exit 9 fires. That is the named budget the falsifier violates.
+| Axis | Declared | Measured (all three) |
+| --- | --- | --- |
+| Stretcher-leg BVH gap | ≤ 0.008 m | 0.00000 |
+| Ferrule inner clearance (`r_wood − r_in`) | −0.005 .. 0.000 m | −0.00125 |
+
+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 may differ
+by a few bytes across series.
+
+### Falsifiers
+
+Each violates one named budget. All seven were run on 4.5.11, 5.1.2 and
+5.2.1 and returned the same code on each.
+
+| Flag | Budget violated | Exit |
+| --- | --- | --- |
+| `--skip-decimate` | LOD1 ratio band | 9 |
+| `--stray-vert` | loose vertex count is 0 | 15 |
+| `--lift-z` | bounding box `zmin` is 0 | 16 |
+| `--short-legs` | named ferrule cups at Z=0 | 16 |
+| `--float-stretchers` | stretcher-leg join | 17 |
+| `--pipe-ferrule` | ferrule inner-clearance band | 18 |
 
 ## Run
 
 ```bash
 blender --background --python tavern_stool.py --
 blender --background --python tavern_stool.py -- --skip-decimate
+blender --background --python tavern_stool.py -- --stray-vert
+blender --background --python tavern_stool.py -- --lift-z
+blender --background --python tavern_stool.py -- --short-legs
+blender --background --python tavern_stool.py -- --float-stretchers
+blender --background --python tavern_stool.py -- --pipe-ferrule
 blender --background --python tavern_stool.py -- --output stool.png
 ```
 
-Smoke does not pass `--output` or `--skip-decimate`.
+Smoke passes no flags.
 
 ## Exit codes
 
 File-local. `9` is a valid check code. `10` is reserved for
-`gallery_framing.check_framing` on the `--output` path.
+`gallery_framing.check_framing` on the `--output` path. `15`–`19` are the
+hygiene and joint-fit family.
 
 | Code | Meaning |
 | --- | --- |
@@ -62,7 +106,7 @@ File-local. `9` is a valid check code. `10` is reserved for
 | 2 | argparse / usage |
 | 3 | Mesh did not build / no UV layer |
 | 4 | Base triangle count outside range |
-| 5 | Material count ≠ 2 distinct slots, or wood/metal faces missing |
+| 5 | Material count ≠ 2 distinct slots, or a face-count floor missed |
 | 6 | UVs outside 0..1 |
 | 7 | UV AABB overlap above tolerance |
 | 8 | World AABB off declared outer size |
@@ -72,3 +116,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 | Mesh hygiene: loose, non-manifold, zero-area, doubles, n-gons, z-fight |
+| 16 | Not grounded: bounding box `zmin` off 0, or a named ferrule cup floats |
+| 17 | Joint fit: stretcher-leg gap |
+| 18 | Seat: ferrule inner-clearance band |
+| 19 | Seat diameter or height off the stated real-world size |
diff --git a/showcase/tavern-stool/preview.webp b/showcase/tavern-stool/preview.webp
index 50b33b5..e466bed 100644
Binary files a/showcase/tavern-stool/preview.webp and b/showcase/tavern-stool/preview.webp differ
diff --git a/showcase/tavern-stool/tavern_stool.py b/showcase/tavern-stool/tavern_stool.py
index 83aab8b..10fe235 100644
--- a/showcase/tavern-stool/tavern_stool.py
+++ b/showcase/tavern-stool/tavern_stool.py
@@ -5,8 +5,11 @@
 normal bake, LOD chain, convex collider, Unity glTF export.
 
 Budgets are declared below and recomputed from the generated result.
-They are not API-contract witnesses. ``--skip-decimate`` skips the LOD
-DECIMATE stage so the LOD-ratio budget fails.
+They are not API-contract witnesses. Each falsifier violates one named
+budget: ``--skip-decimate`` the LOD-ratio band, ``--stray-vert`` mesh
+hygiene, ``--lift-z`` grounded zmin, ``--short-legs`` named ferrule
+supports, ``--float-stretchers`` stretcher joint-fit, ``--pipe-ferrule``
+ferrule-cup seat.
 
 No RNG. Construction is closed-form. DECIMATE COLLAPSE triangle counts
 are not byte-identical across Blender versions — the LOD gate is a
@@ -25,11 +28,9 @@
 
 import bmesh
 import bpy
-from mathutils import Euler, Vector
+from mathutils import Vector
+from mathutils.bvhtree import BVHTree
 
-# Showcase lives at repo-root/showcase/, not under examples/. The framing
-# helper is the repo's only shared import and lives next to the examples;
-# resolve the repo root so we do not move gallery_framing.py.
 _REPO = os.path.abspath(
     os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir, os.pardir)
 )
@@ -37,19 +38,35 @@
 sys.dont_write_bytecode = True
 import gallery_framing  # noqa: E402
 
-SEAT_R = 0.155
-SEAT_T = 0.042
-SEAT_Z = 0.46
+# A short tavern stool: ~34 cm seat, 47 cm to the rim, legs splayed so
+# the feet land near the seat's shadow. The old piece was a 16-gon puck
+# on four stacked cones clustered under the disc.
+SEAT_R = 0.170
+SEAT_T = 0.040
+SEAT_Z = 0.470
+SEAT_SEGS = 48
 N_LEGS = 4
-LEG_TOP_R = 0.078
-LEG_BOT_R = 0.125
-STRETCH_Z = 0.175
-BBOX_TOL = 0.01
+LEG_TOP_R = 0.128
+LEG_BOT_R = 0.202
+LEG_SEGS = 16
+FERRULE_H = 0.022
+FERRULE_T = 0.0045
+FERRULE_SEGS = 16
+STRETCH_T = 0.58
+STRETCH_R = 0.011
+STRETCH_SEGS = 12
+STRETCH_TENON = 0.012
+SEAT_TENON = 0.018
+BBOX_TOL = 0.015
+BODY_DIA = 2.0 * SEAT_R
+BODY_DIA_TOL = 0.02
+BODY_H = SEAT_Z
+BODY_H_TOL = 0.02
 # Fitted after locking geometry. Recomputed from bound_box.
-OUTER_SIZE = (0.309, 0.309, 0.467)
+OUTER_SIZE = (0.341, 0.341, 0.470)
 
-BASE_TRIS_MIN = 5250
-BASE_TRIS_MAX = 5550
+BASE_TRIS_MIN = 2300
+BASE_TRIS_MAX = 3200
 LOD1_RATIO_MIN = 0.32
 LOD1_RATIO_MAX = 0.62
 LOD2_RATIO_MIN = 0.10
@@ -59,15 +76,52 @@
 MATERIAL_COUNT = 2
 UV_EPS = 1e-4
 UV_OVERLAP_MAX = 1e-5
-COLLIDER_TRIS_MAX = 140
+COLLIDER_TRIS_MAX = 640
 BAKE_RES = 256
 CAGE_EXTRUSION = 0.06
-METAL_FACES_MIN = 16
-WOOD_FACES_MIN = 24
+METAL_FACES_MIN = 48
+WOOD_FACES_MIN = 200
+ZMIN_EPS = 1e-4
+DOUBLES_EPS = 1e-5
+AREA_EPS = 1e-10
+ZFIGHT_EPS = 1e-4
+ZFIGHT_COS = 0.999
+LIFT_Z = 0.05
+FERRULE_Z_MAX = 1e-3
+STRETCH_JOIN = 0.008
+FERRULE_BITE_MIN = -0.005
+FERRULE_BITE_MAX = 0.000
 
 WOOD_IDX = 0
 METAL_IDX = 1
 
+# Turned-leg profile: (t along the axis from seat tenon to ferrule, radius).
+# One loft, not four stacked cones. t=0 is up in the seat.
+LEG_PROFILE = (
+    (0.00, 0.018),
+    (0.08, 0.022),
+    (0.20, 0.025),
+    (0.36, 0.016),
+    (0.52, 0.015),
+    (0.60, 0.018),
+    (0.78, 0.016),
+    (0.92, 0.018),
+    (1.00, 0.017),
+)
+
+# Seat, underside to dish. One lathe, not three stacked cylinders.
+# (z above the underside, radius). r=0 is the dish centre.
+SEAT_PROFILE = (
+    (0.000, 0.122),
+    (0.010, 0.138),
+    (0.016, 0.158),
+    (0.022, 0.168),
+    (0.032, 0.170),
+    (0.040, 0.164),
+    (0.037, 0.095),
+    (0.034, 0.000),
+)
+
 
 def eevee_engine_id():
     return "BLENDER_EEVEE" if bpy.app.version >= (5, 0, 0) else "BLENDER_EEVEE_NEXT"
@@ -84,7 +138,6 @@ def triangle_count(mesh):
 
 
 def evaluated_triangle_count(obj):
-    # Duplicated from snippets/lod_chain.py / decimate_to_budget.py (not a package).
     depsgraph = bpy.context.evaluated_depsgraph_get()
     eval_obj = obj.evaluated_get(depsgraph)
     eval_mesh = eval_obj.to_mesh()
@@ -95,92 +148,144 @@ def evaluated_triangle_count(obj):
         eval_obj.to_mesh_clear()
 
 
-def add_box(bm, loc, scale, mat_idx, euler=(0.0, 0.0, 0.0)):
-    geo = bmesh.ops.create_cube(bm, size=1.0)
-    verts = geo["verts"]
-    rot = Euler(euler).to_matrix()
-    origin = Vector(loc)
-    for v in verts:
-        p = Vector((v.co.x * scale[0], v.co.y * scale[1], v.co.z * scale[2]))
-        v.co = rot @ p + origin
-    faces = {f for v in verts for f in v.link_faces}
-    for f in faces:
-        f.material_index = mat_idx
+def _bridge_rings(bm, a, b, mat_idx):
+    if len(a) == 1 and len(b) > 1:
+        c = a[0]
+        for k in range(len(b)):
+            kn = (k + 1) % len(b)
+            face = bm.faces.new((c, b[k], b[kn]))
+            face.material_index = mat_idx
+    elif len(b) == 1 and len(a) > 1:
+        c = b[0]
+        for k in range(len(a)):
+            kn = (k + 1) % len(a)
+            face = bm.faces.new((c, a[kn], a[k]))
+            face.material_index = mat_idx
+    else:
+        segs = len(a)
+        for k in range(segs):
+            kn = (k + 1) % segs
+            face = bm.faces.new((a[k], a[kn], b[kn], b[k]))
+            face.material_index = mat_idx
+
+
+def loft_rings(bm, rings, mat_idx, cap_start=True, cap_end=True, cyclic=False):
+    """Loft a stack of rings. A ring of one vert is a centre cap."""
+    verts = [v for ring in rings for v in ring]
+    n = len(rings)
+    for i in range(n - 1):
+        _bridge_rings(bm, rings[i], rings[i + 1], mat_idx)
+    if cyclic and n > 2:
+        _bridge_rings(bm, rings[-1], rings[0], mat_idx)
+    if cap_start and len(rings[0]) > 1:
+        ring = rings[0]
+        c = bm.verts.new(sum((v.co for v in ring), Vector((0, 0, 0))) / len(ring))
+        verts.append(c)
+        for k in range(len(ring)):
+            kn = (k + 1) % len(ring)
+            face = bm.faces.new((c, ring[kn], ring[k]))
+            face.material_index = mat_idx
+    if cap_end and len(rings[-1]) > 1:
+        ring = rings[-1]
+        c = bm.verts.new(sum((v.co for v in ring), Vector((0, 0, 0))) / len(ring))
+        verts.append(c)
+        for k in range(len(ring)):
+            kn = (k + 1) % len(ring)
+            face = bm.faces.new((c, ring[k], ring[kn]))
+            face.material_index = mat_idx
     return verts
 
 
-def add_oriented_box(bm, a, b, scale_xy, mat_idx):
-    a = Vector(a)
-    b = Vector(b)
-    delta = b - a
-    length = delta.length
-    if length < 1e-8:
-        return []
-    quat = Vector((0.0, 0.0, 1.0)).rotation_difference(delta.normalized())
-    eul = quat.to_euler("XYZ")
-    return add_box(
-        bm,
-        ((a + b) * 0.5),
-        (scale_xy[0], scale_xy[1], length),
-        mat_idx,
-        euler=(eul.x, eul.y, eul.z),
-    )
+def lathe_z(bm, profile, segs, mat_idx, z0=0.0):
+    rings = []
+    for z, r in profile:
+        if r <= 1e-8:
+            rings.append([bm.verts.new((0.0, 0.0, z0 + z))])
+            continue
+        ring = []
+        for i in range(segs):
+            a = 2.0 * math.pi * i / segs
+            ring.append(
+                bm.verts.new((r * math.cos(a), r * math.sin(a), z0 + z))
+            )
+        rings.append(ring)
+    # Profile already ends at r=0 (dish) or a ring. No extra caps.
+    cap_start = len(rings[0]) > 1
+    cap_end = len(rings[-1]) > 1
+    return loft_rings(bm, rings, mat_idx, cap_start=cap_start, cap_end=cap_end)
 
 
-def add_cone_between(bm, a, b, r1, r2, segments, mat_idx):
+def lathe_axis(bm, a, b, profile, segs, mat_idx, cap_start=True, cap_end=True):
     a = Vector(a)
     b = Vector(b)
     delta = b - a
     length = delta.length
     if length < 1e-8:
         return []
-    quat = Vector((0.0, 0.0, 1.0)).rotation_difference(delta.normalized())
-    eul = quat.to_euler("XYZ")
-    return add_cone(
-        bm, (a + b) * 0.5, r1, r2, length, segments, mat_idx,
-        euler=(eul.x, eul.y, eul.z),
+    tangent = delta.normalized()
+    side = Vector((-tangent.y, tangent.x, 0.0))
+    if side.length < 1e-6:
+        side = Vector((1.0, 0.0, 0.0))
+    else:
+        side.normalize()
+    up = tangent.cross(side).normalized()
+    rings = []
+    for t, radius in profile:
+        p = a + tangent * (t * length)
+        if radius <= 1e-8:
+            rings.append([bm.verts.new(p)])
+            continue
+        ring = []
+        for i in range(segs):
+            ang = 2.0 * math.pi * i / segs
+            ring.append(
+                bm.verts.new(p + side * (radius * math.cos(ang)) + up * (radius * math.sin(ang)))
+            )
+        rings.append(ring)
+    return loft_rings(
+        bm, rings, mat_idx, cap_start=cap_start, cap_end=cap_end,
     )
 
 
-def add_cone(bm, loc, radius1, radius2, depth, segments, mat_idx, euler=(0.0, 0.0, 0.0)):
-    geo = bmesh.ops.create_cone(
-        bm,
-        cap_ends=True,
-        cap_tris=False,
-        segments=segments,
-        radius1=radius1,
-        radius2=radius2,
-        depth=depth,
+def add_cup(bm, xy, z0, z1, r_in, r_out, segs, mat_idx):
+    """Vertical ferrule cup: annulus walls, open on the top, planted at z0."""
+    cx, cy = xy
+    specs = (
+        (z0, r_in),
+        (z0, r_out),
+        (z1, r_out),
+        (z1, r_in),
+    )
+    rings = []
+    for z, r in specs:
+        ring = []
+        for i in range(segs):
+            a = 2.0 * math.pi * i / segs
+            ring.append(
+                bm.verts.new((cx + r * math.cos(a), cy + r * math.sin(a), z))
+            )
+        rings.append(ring)
+    return loft_rings(
+        bm, rings, mat_idx, cap_start=False, cap_end=False, cyclic=True,
     )
-    verts = list(geo["verts"])
-    rot = Euler(euler).to_matrix()
-    origin = Vector(loc)
-    for v in verts:
-        v.co = rot @ v.co + origin
-    faces = {f for v in verts for f in v.link_faces}
-    for f in faces:
-        f.material_index = mat_idx
-    return verts
-
-
-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 add_rim(bm, loc, major, minor, mat_idx, euler=(0.0, 0.0, 0.0)):
-    n_major = 12
-    n_minor = 6
+def add_pipe_torus(bm, xy, z, major, minor, mat_idx):
+    """Falsifier: a metal torus planted at z that does not cup the foot."""
+    n_major, n_minor = 12, 4
+    cx, cy = xy
     rings = []
     for i in range(n_major):
         u = i * (2.0 * math.pi / n_major)
         ring = []
         for j in range(n_minor):
             v = j * (2.0 * math.pi / n_minor)
-            x = (major + minor * math.cos(v)) * math.cos(u)
-            y = (major + minor * math.cos(v)) * math.sin(u)
-            z = minor * math.sin(v)
-            ring.append(bm.verts.new((x, y, z)))
+            px = cx + (major + minor * math.cos(v)) * math.cos(u)
+            py = cy + (major + minor * math.cos(v)) * math.sin(u)
+            pz = z + minor * (1.0 + math.sin(v))
+            ring.append(bm.verts.new((px, py, pz)))
         rings.append(ring)
+    verts = [v for ring in rings for v in ring]
     for i in range(n_major):
         i2 = (i + 1) % n_major
         for j in range(n_minor):
@@ -189,11 +294,6 @@ def add_rim(bm, loc, major, minor, mat_idx, euler=(0.0, 0.0, 0.0)):
                 (rings[i][j], rings[i2][j], rings[i2][j2], rings[i][j2])
             )
             face.material_index = mat_idx
-    verts = [v for ring in rings for v in ring]
-    rot = Euler(euler).to_matrix()
-    origin = Vector(loc)
-    for v in verts:
-        v.co = rot @ v.co + origin
     return verts
 
 
@@ -213,9 +313,7 @@ def pack_uvs(bm, margin=0.08):
         col = i % cols
         row = i // cols
         nrm = face.normal
-        ax = abs(nrm.x)
-        ay = abs(nrm.y)
-        az = abs(nrm.z)
+        ax, ay, az = abs(nrm.x), abs(nrm.y), abs(nrm.z)
         coords = []
         for loop in face.loops:
             co = loop.vert.co
@@ -240,86 +338,108 @@ def pack_uvs(bm, margin=0.08):
             )
 
 
-def build_stool_mesh(name, bevel_offset, bevel_segments):
+def _leg_ends(i):
+    ang = math.pi / 4.0 + i * (math.pi * 2.0 / N_LEGS)
+    c, s = math.cos(ang), math.sin(ang)
+    seat_under = SEAT_Z - SEAT_T
+    top = Vector((LEG_TOP_R * c, LEG_TOP_R * s, seat_under + SEAT_TENON))
+    bot = Vector((LEG_BOT_R * c, LEG_BOT_R * s, FERRULE_H + 0.003))
+    foot_xy = (LEG_BOT_R * c, LEG_BOT_R * s)
+    return top, bot, foot_xy, ang
+
+
+def build_stool_mesh(
+    name,
+    short_legs=False,
+    float_stretchers=False,
+    pipe_ferrule=False,
+):
     bm = bmesh.new()
-    wood_verts = []
-    metal_faces = set()
     try:
-        seat_center = (0.0, 0.0, SEAT_Z - SEAT_T / 2.0)
-        wood_verts.extend(add_cylinder(bm, seat_center, SEAT_R, SEAT_T, 16, WOOD_IDX))
-        wood_verts.extend(
-            add_cylinder(
-                bm,
-                (0.0, 0.0, SEAT_Z - SEAT_T - 0.012),
-                SEAT_R - 0.018,
-                0.022,
-                16,
-                WOOD_IDX,
-            )
-        )
-        wood_verts.extend(
-            add_cone(
-                bm,
-                (0.0, 0.0, SEAT_Z + 0.004),
-                SEAT_R - 0.012,
-                SEAT_R,
-                0.010,
-                16,
-                WOOD_IDX,
-            )
-        )
+        wood_faces = []
+        metal_faces = []
+        before = set(bm.faces)
+        lathe_z(bm, SEAT_PROFILE, SEAT_SEGS, WOOD_IDX, z0=SEAT_Z - SEAT_T)
+        wood_faces.extend(set(bm.faces) - before)
+
+        ferrule_z0 = 0.05 if short_legs else 0.0
+        if short_legs:
+            before = set(bm.faces)
+            geo = bmesh.ops.create_cube(bm, size=1.0)
+            for v in geo["verts"]:
+                v.co.x *= 0.024
+                v.co.y *= 0.024
+                v.co.z *= 0.006
+                v.co.z += 0.003
+            metal_faces.extend(set(bm.faces) - before)
 
         leg_pts = []
         for i in range(N_LEGS):
-            ang = math.pi / 4.0 + i * (math.pi * 2.0 / N_LEGS)
-            c, s = math.cos(ang), math.sin(ang)
-            top = Vector((LEG_TOP_R * c, LEG_TOP_R * s, SEAT_Z - SEAT_T - 0.004))
-            bot = Vector((LEG_BOT_R * c, LEG_BOT_R * s, 0.012))
-            leg_pts.append((top, bot, ang))
-            d = bot - top
-            p_knuckle = top + d * 0.22
-            p_ring = top + d * 0.55
-            p_foot = top + d * 0.88
-            wood_verts.extend(add_cone_between(bm, top, p_knuckle, 0.016, 0.024, 8, WOOD_IDX))
-            wood_verts.extend(add_cone_between(bm, p_knuckle, p_ring, 0.018, 0.015, 8, WOOD_IDX))
-            wood_verts.extend(add_cone_between(bm, p_ring, p_foot, 0.022, 0.018, 8, WOOD_IDX))
-            wood_verts.extend(add_cone_between(bm, p_foot, bot, 0.018, 0.028, 8, WOOD_IDX))
+            top, bot, foot_xy, ang = _leg_ends(i)
+            leg_pts.append((top, bot, foot_xy, ang))
             before = set(bm.faces)
-            add_cone_between(bm, bot + Vector((0, 0, 0.006)), bot - Vector((0, 0, 0.010)), 0.030, 0.030, 8, METAL_IDX)
-            metal_faces.update(set(bm.faces) - before)
+            lathe_axis(bm, top, bot, LEG_PROFILE, LEG_SEGS, WOOD_IDX)
+            wood_faces.extend(set(bm.faces) - before)
 
-        for i in range(N_LEGS):
-            a_top, a_bot, _ = leg_pts[i]
-            b_top, b_bot, _ = leg_pts[(i + 1) % N_LEGS]
-            a = a_top.lerp(a_bot, 0.62)
-            b = b_top.lerp(b_bot, 0.62)
-            wood_verts.extend(add_oriented_box(bm, a, b, (0.022, 0.018), WOOD_IDX))
-
-        if bevel_offset > 0.0:
-            edges = list({e for v in wood_verts for e in v.link_edges if v.is_valid})
-            if edges:
-                bmesh.ops.bevel(
+            r_foot = LEG_PROFILE[-1][1]
+            r_in = r_foot + 0.001
+            r_out = r_in + FERRULE_T
+            before = set(bm.faces)
+            if pipe_ferrule:
+                add_pipe_torus(
+                    bm, foot_xy, ferrule_z0, 0.016, 0.006, METAL_IDX,
+                )
+            else:
+                add_cup(
                     bm,
-                    geom=edges,
-                    offset=bevel_offset,
-                    segments=bevel_segments,
-                    profile=0.5,
-                    affect="EDGES",
-                    clamp_overlap=True,
+                    foot_xy,
+                    ferrule_z0,
+                    ferrule_z0 + FERRULE_H,
+                    r_in,
+                    r_out,
+                    FERRULE_SEGS,
+                    METAL_IDX,
                 )
+            metal_faces.extend(set(bm.faces) - before)
+
+        if not float_stretchers:
+            for i in range(N_LEGS):
+                a_top, a_bot, _, _ = leg_pts[i]
+                b_top, b_bot, _, _ = leg_pts[(i + 1) % N_LEGS]
+                a = a_top.lerp(a_bot, STRETCH_T)
+                b = b_top.lerp(b_bot, STRETCH_T)
+                d = (b - a).normalized()
+                r_leg = 0.0
+                for t, r in LEG_PROFILE:
+                    if t >= STRETCH_T:
+                        r_leg = r
+                        break
+                a_end = a + d * (r_leg - STRETCH_TENON)
+                b_end = b - d * (r_leg - STRETCH_TENON)
+                before = set(bm.faces)
+                lathe_axis(
+                    bm, a_end, b_end,
+                    ((0.0, STRETCH_R), (1.0, STRETCH_R)),
+                    STRETCH_SEGS, WOOD_IDX,
+                )
+                wood_faces.extend(set(bm.faces) - before)
 
         pack_uvs(bm)
         bmesh.ops.recalc_face_normals(bm, faces=list(bm.faces))
+        wood_set = set(wood_faces)
+        metal_set = set(metal_faces)
         for face in bm.faces:
-            face.smooth = True
+            if face in metal_set:
+                face.material_index = METAL_IDX
+                face.smooth = True
+            else:
+                face.material_index = WOOD_IDX
+                face.smooth = True
         for edge in bm.edges:
             edge.smooth = True
             if edge.is_manifold and len(edge.link_faces) == 2:
-                if edge.calc_face_angle() > math.radians(35.0):
+                if edge.calc_face_angle() > math.radians(40.0):
                     edge.smooth = False
-        for f in metal_faces:
-            if f.is_valid:
-                f.material_index = METAL_IDX
         me = bpy.data.meshes.new(name)
         bm.to_mesh(me)
         me.update()
@@ -329,27 +449,45 @@ def build_stool_mesh(name, bevel_offset, bevel_segments):
     bpy.context.collection.objects.link(obj)
     return obj
 
-def principled(name, color, metallic, roughness):
+
+def principled(name, color, metallic, roughness, noise_scale=0.0, wear=None):
     mat = bpy.data.materials.new(name)
     mat.use_nodes = True
-    bsdf = mat.node_tree.nodes["Principled BSDF"]
+    nt = mat.node_tree
+    bsdf = nt.nodes["Principled BSDF"]
     bsdf.inputs["Base Color"].default_value = color
     bsdf.inputs["Metallic"].default_value = metallic
     bsdf.inputs["Roughness"].default_value = roughness
+    if noise_scale > 0.0 and wear is not None:
+        tex = nt.nodes.new("ShaderNodeTexNoise")
+        tex.inputs["Scale"].default_value = noise_scale
+        tex.inputs["Detail"].default_value = 8.0
+        tex.inputs["Roughness"].default_value = 0.55
+        mix = nt.nodes.new("ShaderNodeMix")
+        mix.data_type = "RGBA"
+        mix.inputs["A"].default_value = color
+        mix.inputs["B"].default_value = wear
+        fac = mix.inputs.get("Factor") or mix.inputs.get("Fac")
+        nt.links.new(tex.outputs["Fac"], fac)
+        nt.links.new(mix.outputs["Result"], bsdf.inputs["Base Color"])
+        rmix = nt.nodes.new("ShaderNodeMix")
+        rmix.data_type = "FLOAT"
+        rmix.inputs["A"].default_value = roughness
+        rmix.inputs["B"].default_value = min(1.0, roughness + 0.18)
+        rfac = rmix.inputs.get("Factor") or rmix.inputs.get("Fac")
+        nt.links.new(tex.outputs["Fac"], rfac)
+        nt.links.new(rmix.outputs["Result"], bsdf.inputs["Roughness"])
     return mat
 
 
 def assign_slots(obj, wood, metal):
     mats = obj.data.materials
-    if len(mats) == 0:
-        mats.append(wood)
-        mats.append(metal)
-        return
-    mats[0] = wood
-    if len(mats) == 1:
-        mats.append(metal)
-    else:
-        mats[1] = metal
+    wanted = (wood, metal)
+    for i, mat in enumerate(wanted):
+        if i < len(mats):
+            mats[i] = mat
+        else:
+            mats.append(mat)
 
 
 def world_bbox(obj):
@@ -385,6 +523,253 @@ def uv_stats(mesh):
     return min(us), min(vs), max(us), max(vs), overlap, len(aabbs)
 
 
+def face_area(me, poly):
+    idxs = poly.vertices
+    if len(idxs) < 3:
+        return 0.0
+    v0 = me.vertices[idxs[0]].co
+    area = 0.0
+    for i in range(1, len(idxs) - 1):
+        vs = (me.vertices[idxs[i]].co, me.vertices[idxs[i + 1]].co)
+        area += (vs[0] - v0).cross(vs[1] - v0).length * 0.5
+    return area
+
+
+def hygiene_audit(me):
+    nv, ne, nf = len(me.vertices), len(me.edges), len(me.polygons)
+    ngons = sum(1 for p in me.polygons if len(p.vertices) > 4)
+    zero_area = sum(1 for p in me.polygons if face_area(me, p) <= AREA_EPS)
+    bm = bmesh.new()
+    try:
+        bm.from_mesh(me)
+        bm.verts.ensure_lookup_table()
+        bm.edges.ensure_lookup_table()
+        loose_v = sum(1 for v in bm.verts if len(v.link_edges) == 0)
+        loose_e = sum(1 for e in bm.edges if len(e.link_faces) == 0)
+        nonman = sum(1 for e in bm.edges if not e.is_manifold)
+        ret = bmesh.ops.find_doubles(bm, verts=list(bm.verts), dist=DOUBLES_EPS)
+        doubles = len(ret.get("targetmap") or {})
+    finally:
+        bm.free()
+    return {
+        "nv": nv, "ne": ne, "nf": nf, "ngons": ngons,
+        "loose_v": loose_v, "loose_e": loose_e, "nonman": nonman,
+        "zero_area": zero_area, "doubles": doubles, "euler": nv - ne + nf,
+    }
+
+
+def zfight_pairs(me):
+    data = [
+        (p.center.copy(), p.normal.copy(), frozenset(p.vertices))
+        for p in me.polygons
+    ]
+    eps2 = ZFIGHT_EPS * ZFIGHT_EPS
+    count = 0
+    for i in range(len(data)):
+        ci, ni, vi = data[i]
+        for j in range(i + 1, len(data)):
+            cj, nj, vj = data[j]
+            if (cj - ci).length_squared > eps2:
+                continue
+            if abs(ni.dot(nj)) <= ZFIGHT_COS:
+                continue
+            if vi & vj:
+                continue
+            count += 1
+    return count
+
+
+def shells(me):
+    neighbors = [[] for _ in range(len(me.vertices))]
+    for edge in me.edges:
+        a, b = edge.vertices
+        neighbors[a].append(b)
+        neighbors[b].append(a)
+    seen = [False] * len(me.vertices)
+    groups = []
+    for start in range(len(me.vertices)):
+        if seen[start]:
+            continue
+        seen[start] = True
+        stack = [start]
+        group = []
+        while stack:
+            current = stack.pop()
+            group.append(current)
+            for nxt in neighbors[current]:
+                if not seen[nxt]:
+                    seen[nxt] = True
+                    stack.append(nxt)
+        groups.append(group)
+    return groups
+
+
+def shell_aabb(me, group):
+    pts = [me.vertices[i].co for i in group]
+    return (
+        min(p.x for p in pts), min(p.y for p in pts), min(p.z for p in pts),
+        max(p.x for p in pts), max(p.y for p in pts), max(p.z for p in pts),
+    )
+
+
+def mat_of(me, group):
+    member = set(group)
+    for p in me.polygons:
+        if all(i in member for i in p.vertices):
+            return p.material_index
+    return None
+
+
+def support_audit(me):
+    groups = shells(me)
+    cups = []
+    for g in groups:
+        if mat_of(me, g) != METAL_IDX:
+            continue
+        a = shell_aabb(me, g)
+        dx, dy, dz = a[3] - a[0], a[4] - a[1], a[5] - a[2]
+        if a[5] < 0.08 and dx > 0.03 and dy > 0.03 and dz < 0.05:
+            cups.append(a)
+    cup_z = min((a[2] for a in cups), default=99.0)
+    return {"cups": len(cups), "cup_z": cup_z}
+
+
+def seat_audit(me):
+    groups = shells(me)
+    best = None
+    best_area = -1.0
+    for g in groups:
+        if mat_of(me, g) != WOOD_IDX:
+            continue
+        a = shell_aabb(me, g)
+        dx, dy, dz = a[3] - a[0], a[4] - a[1], a[5] - a[2]
+        area = dx * dy
+        if dz > 0.02 and area > best_area:
+            best_area = area
+            best = a
+    if best is None:
+        return {"dia": 0.0, "height": 0.0, "zmin": 99.0}
+    dia = 0.5 * ((best[3] - best[0]) + (best[4] - best[1]))
+    return {"dia": dia, "height": best[5], "zmin": best[2]}
+
+
+def stretcher_join(me):
+    """Worst gap from a stretcher shell to the nearest leg."""
+    groups = shells(me)
+    legs = []
+    stretchers = []
+    for g in groups:
+        if mat_of(me, g) != WOOD_IDX:
+            continue
+        a = shell_aabb(me, g)
+        dx, dy, dz = a[3] - a[0], a[4] - a[1], a[5] - a[2]
+        if dz > 0.20 and max(dx, dy) < 0.16:
+            legs.append(g)
+        elif dz < 0.035 and 0.10 < max(dx, dy) < 0.30:
+            stretchers.append(g)
+    if not legs or not stretchers:
+        return 99.0
+    bm_leg = bmesh.new()
+    try:
+        bm_leg.from_mesh(me)
+        keep = set()
+        for g in legs:
+            keep.update(g)
+        drop = [
+            f for f in bm_leg.faces
+            if not all(v.index in keep for v in f.verts)
+        ]
+        if drop:
+            bmesh.ops.delete(bm_leg, geom=drop, context="FACES")
+        if not bm_leg.faces:
+            return 99.0
+        tree = BVHTree.FromBMesh(bm_leg)
+        worst = 0.0
+        for g in stretchers:
+            bm_s = bmesh.new()
+            try:
+                bm_s.from_mesh(me)
+                member = set(g)
+                drop_s = [
+                    f for f in bm_s.faces
+                    if not all(v.index in member for v in f.verts)
+                ]
+                if drop_s:
+                    bmesh.ops.delete(bm_s, geom=drop_s, context="FACES")
+                if not bm_s.faces:
+                    worst = max(worst, 99.0)
+                    continue
+                tree_s = BVHTree.FromBMesh(bm_s)
+                if tree.overlap(tree_s):
+                    continue
+                best = 99.0
+                for i in g:
+                    hit = tree.find_nearest(me.vertices[i].co)
+                    if hit[0] is None:
+                        continue
+                    best = min(best, hit[3])
+                if best > worst:
+                    worst = best
+            finally:
+                bm_s.free()
+        return worst
+    finally:
+        bm_leg.free()
+
+
+def ferrule_bite(me):
+    """How far the ferrule inner wall sits inside the foot radius.
+
+    Sample metal verts on the inner ring (closest to the foot axis) against
+    wood at the same angle. A torus planted around the foot has no inner
+    bite; a cup does.
+    """
+    groups = shells(me)
+    cups = []
+    woods = []
+    for g in groups:
+        a = shell_aabb(me, g)
+        if mat_of(me, g) == METAL_IDX and a[5] < 0.08:
+            cups.append(g)
+        elif mat_of(me, g) == WOOD_IDX and a[2] < 0.08 and (a[5] - a[2]) > 0.15:
+            woods.append(g)
+    if not cups or not woods:
+        return 0.0
+    wood_pts = [me.vertices[i].co for g in woods for i in g if me.vertices[i].co.z < 0.08]
+    if not wood_pts:
+        return 0.0
+    bites = []
+    for g in cups:
+        pts = [me.vertices[i].co for i in g]
+        cx = sum(p.x for p in pts) / len(pts)
+        cy = sum(p.y for p in pts) / len(pts)
+        inner = min(pts, key=lambda p: (p.x - cx) ** 2 + (p.y - cy) ** 2)
+        r_in = math.hypot(inner.x - cx, inner.y - cy)
+        ring = [
+            p for p in wood_pts
+            if 0.008 < math.hypot(p.x - cx, p.y - cy) < 0.06 and p.z < 0.05
+        ]
+        if not ring:
+            continue
+        foot = min(ring, key=lambda p: math.hypot(p.x - cx, p.y - cy))
+        r_wood = math.hypot(foot.x - cx, foot.y - cy)
+        bites.append(r_wood - r_in)
+    if not bites:
+        return 0.0
+    return min(bites)
+
+
+def add_stray_vert(me):
+    bm = bmesh.new()
+    try:
+        bm.from_mesh(me)
+        bm.verts.new((0.0, 0.0, SEAT_Z))
+        bm.to_mesh(me)
+        me.update()
+    finally:
+        bm.free()
+
+
 def make_lod(obj, name, ratio, skip_decimate):
     mesh = obj.data.copy()
     lod = bpy.data.objects.new(name, mesh)
@@ -398,7 +783,6 @@ def make_lod(obj, name, ratio, skip_decimate):
 
 
 def convex_hull_collider(obj, name):
-    # Duplicated from snippets/convex_hull_collider.py (not a package).
     mesh = bpy.data.meshes.new(name)
     bm = bmesh.new()
     try:
@@ -421,7 +805,6 @@ def convex_hull_collider(obj, name):
 
 
 def setup_bake_image(obj, target_mat, size=BAKE_RES):
-    # Adapted from snippets/setup_bake_target_image.py — do not replace slots.
     if not obj.data.uv_layers:
         return None, None
     img = bpy.data.images.new("StoolNrm", size, size, alpha=True, float_buffer=False)
@@ -436,7 +819,6 @@ def setup_bake_image(obj, target_mat, size=BAKE_RES):
 
 
 def bake_normal(high, low):
-    # Duplicated from snippets/bake_normal_high_to_low.py (not a package).
     scene = bpy.context.scene
     scene.render.engine = "CYCLES"
     scene.cycles.device = "CPU"
@@ -461,7 +843,6 @@ def bake_normal(high, low):
 
 
 def export_unity(path, objects):
-    # Duplicated from snippets/export_preset_unity.py (not a package).
     for ob in bpy.context.view_layer.objects:
         ob.select_set(False)
     for ob in objects:
@@ -477,14 +858,39 @@ def export_unity(path, objects):
     )
 
 
-def check(skip_decimate):
+def check(
+    skip_decimate,
+    lift_z=False,
+    stray_vert=False,
+    short_legs=False,
+    float_stretchers=False,
+    pipe_ferrule=False,
+):
     bpy.ops.wm.read_factory_settings(use_empty=True)
-    low = build_stool_mesh("StoolLow", bevel_offset=0.003, bevel_segments=2)
-    high = build_stool_mesh("StoolHigh", bevel_offset=0.003, bevel_segments=4)
-    wood = principled("StoolWood", (0.44, 0.26, 0.10, 1.0), 0.0, 0.48)
-    metal = principled("StoolMetal", (0.55, 0.52, 0.48, 1.0), 1.0, 0.28)
+    flags = dict(
+        short_legs=short_legs,
+        float_stretchers=float_stretchers,
+        pipe_ferrule=pipe_ferrule,
+    )
+    low = build_stool_mesh("StoolLow", **flags)
+    high = build_stool_mesh("StoolHigh", **flags)
+    wood = principled(
+        "StoolWood", (0.46, 0.26, 0.10, 1.0), 0.0, 0.50,
+        noise_scale=7.0, wear=(0.28, 0.14, 0.05, 1.0),
+    )
+    metal = principled(
+        "StoolMetal", (0.50, 0.48, 0.44, 1.0), 1.0, 0.32,
+        noise_scale=5.0, wear=(0.22, 0.20, 0.18, 1.0),
+    )
     assign_slots(low, wood, metal)
     assign_slots(high, wood, metal)
+    if stray_vert:
+        add_stray_vert(low.data)
+    if lift_z:
+        for v in low.data.vertices:
+            v.co.z += LIFT_Z
+        low.data.update()
+        bpy.context.view_layer.update()
 
     if low.data is None or len(low.data.polygons) < 6:
         return fail("stool mesh did not build", 3), None, None, None, None, None
@@ -516,7 +922,7 @@ def check(skip_decimate):
     r1 = lod1_tris / base_tris if base_tris else 0.0
     r2 = lod2_tris / base_tris if base_tris else 0.0
 
-    collider_src = build_stool_mesh("StoolColSrc", bevel_offset=0.0, bevel_segments=1)
+    collider_src = build_stool_mesh("StoolColSrc", **flags)
     collider = convex_hull_collider(collider_src, "StoolCollider")
     bpy.data.objects.remove(collider_src, do_unlink=True)
     col_tris = triangle_count(collider.data)
@@ -530,9 +936,14 @@ def check(skip_decimate):
     export_unity(export_path, [low, collider])
     export_size = os.path.getsize(export_path) if os.path.isfile(export_path) else 0
 
-    print(
-        f"blender={tuple(bpy.app.version)} skip_decimate={skip_decimate}"
-    )
+    hyg = hygiene_audit(low.data)
+    zf = zfight_pairs(low.data)
+    sup = support_audit(low.data)
+    st = seat_audit(low.data)
+    sj = stretcher_join(low.data)
+    bite = ferrule_bite(low.data)
+
+    print(f"blender={tuple(bpy.app.version)} skip_decimate={skip_decimate}")
     print(
         f"measured base_tris={base_tris} lod1_tris={lod1_tris} "
         f"lod2_tris={lod2_tris} r1={r1:.4f} r2={r2:.4f}"
@@ -549,6 +960,16 @@ def check(skip_decimate):
         f"measured collider_tris={col_tris} bake={bake_result} "
         f"bake_has_data={img.has_data} export_bytes={export_size}"
     )
+    print(
+        f"measured hygiene loose_v={hyg['loose_v']} loose_e={hyg['loose_e']} "
+        f"nonman={hyg['nonman']} zero_area={hyg['zero_area']} "
+        f"doubles={hyg['doubles']} ngons={hyg['ngons']} zfight={zf}"
+    )
+    print(
+        f"measured supports cups={sup['cups']} cup_z={sup['cup_z']:.5f} "
+        f"seat_dia={st['dia']:.4f} seat_h={st['height']:.4f} "
+        f"stretch_join={sj:.5f} ferrule_bite={bite:.5f}"
+    )
 
     if not (BASE_TRIS_MIN <= base_tris <= BASE_TRIS_MAX):
         return fail(
@@ -613,6 +1034,51 @@ def check(skip_decimate):
         ), None, None, None, None, None
     if export_size <= 0:
         return fail("export file missing or empty", 13), None, None, None, None, None
+    if (
+        hyg["loose_v"] or hyg["loose_e"] or hyg["nonman"]
+        or hyg["zero_area"] or hyg["doubles"] or hyg["ngons"] or zf
+    ):
+        return fail(
+            f"hygiene loose_v={hyg['loose_v']} loose_e={hyg['loose_e']} "
+            f"nonman={hyg['nonman']} zero_area={hyg['zero_area']} "
+            f"doubles={hyg['doubles']} ngons={hyg['ngons']} zfight={zf}",
+            15,
+        ), None, None, None, None, None
+    if abs(bb[2]) > ZMIN_EPS:
+        return fail(
+            f"zmin {bb[2]:.6f} not within {ZMIN_EPS} of 0 "
+            "(--lift-z is the designed fail)",
+            16,
+        ), None, None, None, None, None
+    if sup["cups"] < 4 or sup["cup_z"] > FERRULE_Z_MAX:
+        return fail(
+            f"ferrule supports {sup['cups']} cup_z={sup['cup_z']:.5f} "
+            "(--short-legs is the designed fail)",
+            16,
+        ), None, None, None, None, None
+    if sj > STRETCH_JOIN:
+        return fail(
+            f"stretcher-leg gap {sj:.5f} > {STRETCH_JOIN} "
+            "(--float-stretchers is the designed fail)",
+            17,
+        ), None, None, None, None, None
+    if not (FERRULE_BITE_MIN <= bite <= FERRULE_BITE_MAX):
+        return fail(
+            f"ferrule bite {bite:.5f} not in "
+            f"[{FERRULE_BITE_MIN}, {FERRULE_BITE_MAX}] "
+            "(--pipe-ferrule is the designed fail)",
+            18,
+        ), None, None, None, None, None
+    if abs(st["dia"] - BODY_DIA) > BODY_DIA_TOL:
+        return fail(
+            f"seat diameter {st['dia']:.4f} off {BODY_DIA}",
+            19,
+        ), None, None, None, None, None
+    if abs(st["height"] - BODY_H) > BODY_H_TOL:
+        return fail(
+            f"seat height {st['height']:.4f} off {BODY_H}",
+            19,
+        ), None, None, None, None, None
     return 0, low, high, wood, tex, collider
 
 
@@ -680,7 +1146,7 @@ def light(name, loc, energy, size, col, rot):
     cam_data = bpy.data.cameras.new("Cam")
     cam_data.lens = 50.0
     cam = bpy.data.objects.new("Cam", cam_data)
-    cam.location = (0.94, -1.26, 0.90)
+    cam.location = (1.05, -1.38, 0.92)
     scene.collection.objects.link(cam)
     aim = bpy.data.objects.new("Aim", None)
     aim.location = (0.0, 0.0, 0.26)
@@ -726,14 +1192,22 @@ def main():
     p = argparse.ArgumentParser()
     p.add_argument("--output", default=None)
     p.add_argument("--engine", default="eevee", choices=("eevee", "cycles"))
-    p.add_argument(
-        "--skip-decimate",
-        action="store_true",
-        help="falsification: skip the LOD DECIMATE stage",
-    )
+    p.add_argument("--skip-decimate", action="store_true")
+    p.add_argument("--lift-z", action="store_true")
+    p.add_argument("--stray-vert", action="store_true")
+    p.add_argument("--short-legs", action="store_true")
+    p.add_argument("--float-stretchers", action="store_true")
+    p.add_argument("--pipe-ferrule", action="store_true")
     args = p.parse_args(argv)
 
-    code, low, _high, wood, tex, _col = check(args.skip_decimate)
+    code, low, _high, wood, tex, _col = check(
+        args.skip_decimate,
+        lift_z=args.lift_z,
+        stray_vert=args.stray_vert,
+        short_legs=args.short_legs,
+        float_stretchers=args.float_stretchers,
+        pipe_ferrule=args.pipe_ferrule,
+    )
     if code:
         return code
     if args.output:
diff --git a/showcase/treasure-chest/README.md b/showcase/treasure-chest/README.md
index d3488b9..87d9bf4 100644
--- a/showcase/treasure-chest/README.md
+++ b/showcase/treasure-chest/README.md
@@ -1,9 +1,15 @@
 # Treasure chest
 
-A showcase piece, not an example. Procedural slatted treasure chest
-(hollow body, open lid, iron bands, corner brackets, lock plate) 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 iron-bound chest (slatted
+hollow body, barrel-vault lid, U-wrap bands, corner irons, lock plate,
+hinge barrels with lid knuckles, wooden feet) then the shipped pipeline:
+unique-cell UVs, Cycles high-to-low normal bake, LOD chain, convex
+collider, Unity glTF export.
+
+The lid is one lofted vault slab, not stacked boxes. Hinge join is
+measured from local lid knuckles over the barrels — a spanning stile
+only has verts at the X ends, 8 cm from the knuckles, and reports a
+false gap.
 
 It asserts **budget conformance** of the generated result. It does not
 witness an API contract. "It rendered without error" is not a check.
@@ -21,38 +27,78 @@ materials, UVs, evaluated LOD, collider, or export file.
 
 | Axis | Declared | Measured (4.5.11 / 5.1.2 / 5.2.1) |
 | --- | --- | --- |
-| Base triangles | 5600–5850 | 5724 / 5724 / 5724 |
+| Base triangles | 3600–4500 | 3852 / 3852 / 3852 |
 | LOD1 ratio | 0.32–0.62 of base | 0.5000 / 0.5000 / 0.5000 |
-| LOD2 ratio | 0.10–0.35 of base | 0.2198 / 0.2198 / 0.2198 |
-| Materials | exactly 2 distinct, ≥24 metal faces | 2 slots, 180 metal |
+| LOD2 ratio | 0.10–0.35 of base | 0.2196 / 0.2196 / 0.2129 |
+| Materials | exactly 2 distinct; ≥200 wood, ≥80 metal faces | 2 slots; 1608 / 318 |
 | UVs | in `0..1`, AABB overlap ≤ 1e-5 | in range, overlap 0 |
-| Outer AABB | (0.776, 0.549, 0.631) m ± 0.01 | (0.7760, 0.5486, 0.6312), zmin 0 |
-| Collider tris | ≤ 160 | 138 |
-| Export | written, size > 0 | 416656 / 416656 / 416644 bytes |
+| Outer AABB | (0.764, 0.542, 0.691) m ± 0.015 | (0.7640, 0.5423, 0.6907), zmin 0 |
+| Collider tris | ≤ 200 | 176 |
+| Export | written, size > 0 | 288196 / 288196 / 288184 bytes |
+
+### Hygiene
+
+Recomputed from the generated mesh, not asserted about the script.
 
-DECIMATE COLLAPSE triangle counts are **not** guaranteed identical across
-series — the gate is a ratio band, not an exact count. This mesh happened
-to match on 4.5.11 / 5.1.2 / 5.2.1. Bake pixels are stochastic; the gate
-is `has_data` plus operator `FINISHED`, not byte-identity. Construction
-uses no RNG. glTF byte size differs by a few bytes across series.
+| Axis | Declared | Measured (all three) |
+| --- | --- | --- |
+| Non-manifold edges | 0 | 0 |
+| Loose verts / edges | 0 / 0 | 0 / 0 |
+| Doubles merged at 1e-5 | 0 | 0 |
+| Zero-area faces | 0 | 0 |
+| N-gons | 0 | 0 |
+| Coplanar disjoint face pairs | 0 | 0 |
+| Grounded: `zmin` | within 1e-4 of 0 | 0.0000 |
+| Named supports: 4 feet | each `zmin` ≤ 1e-3 | 4, foot_z 0.00000 |
+| Body plan | 0.74 × 0.46 m ± 0.04 | 0.7400 × 0.4600 |
+
+### Joint fit and seat
 
-`--skip-decimate` skips the LOD DECIMATE stage so LOD1 ratio is 1.0 and
-exit 9 fires. That is the named budget the falsifier violates.
+| Axis | Declared | Measured (all three) |
+| --- | --- | --- |
+| Lid-knuckle to hinge barrel | ≤ 0.020 m | 0.00700 |
+| Band-wall BVH gap | ≤ 0.008 m | 0.00000 |
+
+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 may differ
+by a few bytes across series.
+
+### Falsifiers
+
+Each violates one named budget. All seven were run on 4.5.11, 5.1.2 and
+5.2.1 and returned the same code on each.
+
+| Flag | Budget violated | Exit |
+| --- | --- | --- |
+| `--skip-decimate` | LOD1 ratio band | 9 |
+| `--stray-vert` | loose vertex count is 0 | 15 |
+| `--lift-z` | bounding box `zmin` is 0 | 16 |
+| `--short-legs` | named foot supports at Z=0 | 16 |
+| `--float-hinge` | lid-knuckle to hinge barrel | 17 |
+| `--narrow-bands` | band-wall seat | 18 |
 
 ## Run
 
 ```bash
 blender --background --python treasure_chest.py --
 blender --background --python treasure_chest.py -- --skip-decimate
+blender --background --python treasure_chest.py -- --stray-vert
+blender --background --python treasure_chest.py -- --lift-z
+blender --background --python treasure_chest.py -- --short-legs
+blender --background --python treasure_chest.py -- --float-hinge
+blender --background --python treasure_chest.py -- --narrow-bands
 blender --background --python treasure_chest.py -- --output chest.png
 ```
 
-Smoke does not pass `--output` or `--skip-decimate`.
+Smoke passes no flags.
 
 ## Exit codes
 
 File-local. `9` is a valid check code. `10` is reserved for
-`gallery_framing.check_framing` on the `--output` path.
+`gallery_framing.check_framing` on the `--output` path. `15`–`19` are the
+hygiene and joint-fit family.
 
 | Code | Meaning |
 | --- | --- |
@@ -61,7 +107,7 @@ File-local. `9` is a valid check code. `10` is reserved for
 | 2 | argparse / usage |
 | 3 | Mesh did not build / no UV layer |
 | 4 | Base triangle count outside range |
-| 5 | Material count ≠ 2 distinct slots, or metal faces missing |
+| 5 | Material count ≠ 2 distinct slots, or a face-count floor missed |
 | 6 | UVs outside 0..1 |
 | 7 | UV AABB overlap above tolerance |
 | 8 | World AABB off declared outer size |
@@ -71,3 +117,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 | Mesh hygiene: loose, non-manifold, zero-area, doubles, n-gons, z-fight |
+| 16 | Not grounded: bounding box `zmin` off 0, or a named foot floats |
+| 17 | Joint fit: lid-knuckle to hinge barrel |
+| 18 | Seat: band-wall gap |
+| 19 | Body plan off the stated real-world size |
diff --git a/showcase/treasure-chest/preview.webp b/showcase/treasure-chest/preview.webp
index 25cef64..449a1c5 100644
Binary files a/showcase/treasure-chest/preview.webp and b/showcase/treasure-chest/preview.webp differ
diff --git a/showcase/treasure-chest/treasure_chest.py b/showcase/treasure-chest/treasure_chest.py
index 8520625..e28a6ee 100644
--- a/showcase/treasure-chest/treasure_chest.py
+++ b/showcase/treasure-chest/treasure_chest.py
@@ -5,8 +5,11 @@
 normal bake, LOD chain, convex collider, Unity glTF export.
 
 Budgets are declared below and recomputed from the generated result.
-They are not API-contract witnesses. ``--skip-decimate`` skips the LOD
-DECIMATE stage so the LOD-ratio budget fails.
+They are not API-contract witnesses. Each falsifier violates one named
+budget: ``--skip-decimate`` the LOD-ratio band, ``--stray-vert`` mesh
+hygiene, ``--lift-z`` grounded zmin, ``--short-legs`` named foot
+supports, ``--float-hinge`` lid-hinge joint-fit, ``--narrow-bands``
+band-wall seat.
 
 No RNG. Construction is closed-form. DECIMATE COLLAPSE triangle counts
 are not byte-identical across Blender versions — the LOD gate is a
@@ -26,10 +29,8 @@
 import bmesh
 import bpy
 from mathutils import Euler, Vector
+from mathutils.bvhtree import BVHTree
 
-# Showcase lives at repo-root/showcase/, not under examples/. The framing
-# helper is the repo's only shared import and lives next to the examples;
-# resolve the repo root so we do not move gallery_framing.py.
 _REPO = os.path.abspath(
     os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir, os.pardir)
 )
@@ -37,25 +38,37 @@
 sys.dont_write_bytecode = True
 import gallery_framing  # noqa: E402
 
+# A small iron-bound chest: 0.74 × 0.46 m plan, ~0.37 m to the rim,
+# shallow barrel-vault lid. The old piece was a crate of overlay boxes
+# with a flat sandwich lid.
 OUTER_W = 0.74
 OUTER_D = 0.46
-CAVITY_H = 0.30
-WALL = 0.030
-BOTTOM = 0.028
-FOOT_H = 0.038
-FOOT_S = 0.072
-LID_T = 0.032
-LID_LIP = 0.042
-SLAT_T = 0.018
+CAVITY_H = 0.28
+WALL = 0.028
+BOTTOM = 0.026
+FOOT_H = 0.042
+FOOT_S = 0.068
+FOOT_NEST = 0.012
+LID_T = 0.028
 N_FRONT = 5
+N_SIDE = 4
 N_LID = 5
-BAND_W = 0.048
-BAND_T = 0.016
-LID_ANGLE = math.radians(-26.0)
-BBOX_TOL = 0.01
-OUTER_SIZE = (0.776, 0.549, 0.631)
-BASE_TRIS_MIN = 5600
-BASE_TRIS_MAX = 5850
+BAND_W = 0.042
+BAND_T = 0.010
+VAULT_R = 0.50
+HINGE_R = 0.011
+LID_ANGLE = math.radians(-38.0)
+BRACKET = 0.050
+IRON_T = 0.012
+BBOX_TOL = 0.015
+BODY_W = OUTER_W
+BODY_D = OUTER_D
+BODY_W_TOL = 0.04
+BODY_D_TOL = 0.04
+OUTER_SIZE = (0.764, 0.542, 0.691)
+
+BASE_TRIS_MIN = 3600
+BASE_TRIS_MAX = 4500
 LOD1_RATIO_MIN = 0.32
 LOD1_RATIO_MAX = 0.62
 LOD2_RATIO_MIN = 0.10
@@ -65,10 +78,20 @@
 MATERIAL_COUNT = 2
 UV_EPS = 1e-4
 UV_OVERLAP_MAX = 1e-5
-COLLIDER_TRIS_MAX = 160
+COLLIDER_TRIS_MAX = 200
 BAKE_RES = 256
 CAGE_EXTRUSION = 0.06
-METAL_FACES_MIN = 24
+METAL_FACES_MIN = 80
+WOOD_FACES_MIN = 200
+ZMIN_EPS = 1e-4
+DOUBLES_EPS = 1e-5
+AREA_EPS = 1e-10
+ZFIGHT_EPS = 1e-4
+ZFIGHT_COS = 0.999
+LIFT_Z = 0.05
+FOOT_Z_MAX = 1e-3
+HINGE_JOIN = 0.020
+BAND_SEAT = 0.008
 
 WOOD_IDX = 0
 METAL_IDX = 1
@@ -89,7 +112,6 @@ def triangle_count(mesh):
 
 
 def evaluated_triangle_count(obj):
-    # Duplicated from snippets/lod_chain.py / decimate_to_budget.py (not a package).
     depsgraph = bpy.context.evaluated_depsgraph_get()
     eval_obj = obj.evaluated_get(depsgraph)
     eval_mesh = eval_obj.to_mesh()
@@ -111,6 +133,34 @@ def add_box(bm, loc, scale, mat_idx, euler=(0.0, 0.0, 0.0)):
     faces = {f for v in verts for f in v.link_faces}
     for f in faces:
         f.material_index = mat_idx
+    return list(verts)
+
+
+def add_arc_slab(bm, cz, a0, a1, r_in, r_out, x0, x1, n, mat_idx):
+    """Solid barrel-vault slab along X. Inner/outer arcs, two X stations."""
+    def mk(x, r, t):
+        return bm.verts.new((x, r * math.sin(t), cz + r * math.cos(t)))
+
+    rin, rout, lin, lout = [], [], [], []
+    for i in range(n + 1):
+        t = a0 + (a1 - a0) * (i / float(n))
+        rin.append(mk(x0, r_in, t))
+        rout.append(mk(x0, r_out, t))
+        lin.append(mk(x1, r_in, t))
+        lout.append(mk(x1, r_out, t))
+    verts = rin + rout + lin + lout
+
+    def face(vs):
+        f = bm.faces.new(vs)
+        f.material_index = mat_idx
+
+    for i in range(n):
+        face((rin[i], lin[i], lin[i + 1], rin[i + 1]))
+        face((rout[i], rout[i + 1], lout[i + 1], lout[i]))
+        face((rin[i], rin[i + 1], rout[i + 1], rout[i]))
+        face((lin[i], lout[i], lout[i + 1], lin[i + 1]))
+    face((rin[0], rout[0], lout[0], lin[0]))
+    face((rin[-1], lin[-1], lout[-1], rout[-1]))
     return verts
 
 
@@ -130,9 +180,7 @@ def pack_uvs(bm, margin=0.08):
         col = i % cols
         row = i // cols
         nrm = face.normal
-        ax = abs(nrm.x)
-        ay = abs(nrm.y)
-        az = abs(nrm.z)
+        ax, ay, az = abs(nrm.x), abs(nrm.y), abs(nrm.z)
         coords = []
         for loop in face.loops:
             co = loop.vert.co
@@ -157,31 +205,44 @@ def pack_uvs(bm, margin=0.08):
             )
 
 
-def build_chest_mesh(name, bevel_offset, bevel_segments):
+def build_chest_mesh(
+    name, bevel_offset, bevel_segments,
+    short_legs=False, float_hinge=False, narrow_bands=False,
+):
     bm = bmesh.new()
     try:
-        bevel_verts = []
-        lid_verts = []
-        body_top = FOOT_H + BOTTOM + CAVITY_H
+        wood = []
+        metal = []
+        lid_wood = []
+        lid_metal = []
         hx = OUTER_W / 2.0
         hy = OUTER_D / 2.0
+        body_top = FOOT_H + BOTTOM + CAVITY_H
+        wall_h = CAVITY_H
+        wall_z = FOOT_H + BOTTOM + wall_h / 2.0
+        foot_z0 = 0.05 if short_legs else 0.0
+
+        if short_legs:
+            metal.extend(
+                add_box(bm, (0.0, 0.0, 0.004), (0.04, 0.04, 0.008), METAL_IDX)
+            )
 
         for sxn in (-1.0, 1.0):
             for syn in (-1.0, 1.0):
-                bevel_verts.extend(
+                wood.extend(
                     add_box(
                         bm,
                         (
-                            sxn * (hx - FOOT_S / 2.0 - 0.01),
-                            syn * (hy - FOOT_S / 2.0 - 0.01),
-                            FOOT_H / 2.0,
+                            sxn * (hx - FOOT_S / 2.0 - 0.010),
+                            syn * (hy - FOOT_S / 2.0 - 0.010),
+                            foot_z0 + (FOOT_H + FOOT_NEST) / 2.0,
                         ),
-                        (FOOT_S, FOOT_S, FOOT_H),
-                        METAL_IDX,
+                        (FOOT_S, FOOT_S, FOOT_H + FOOT_NEST),
+                        WOOD_IDX,
                     )
                 )
 
-        bevel_verts.extend(
+        wood.extend(
             add_box(
                 bm,
                 (0.0, 0.0, FOOT_H + BOTTOM / 2.0),
@@ -189,212 +250,240 @@ def build_chest_mesh(name, bevel_offset, bevel_segments):
                 WOOD_IDX,
             )
         )
-        wall_h = CAVITY_H
-        wall_z = FOOT_H + BOTTOM + wall_h / 2.0
-        bevel_verts.extend(
-            add_box(
-                bm,
-                (0.0, -hy + WALL / 2.0, wall_z),
-                (OUTER_W, WALL, wall_h),
-                WOOD_IDX,
-            )
-        )
-        bevel_verts.extend(
-            add_box(
-                bm,
-                (0.0, hy - WALL / 2.0, wall_z),
-                (OUTER_W, WALL, wall_h),
-                WOOD_IDX,
-            )
-        )
-        inner_d = OUTER_D - 2.0 * WALL
-        bevel_verts.extend(
-            add_box(
-                bm,
-                (-hx + WALL / 2.0, 0.0, wall_z),
-                (WALL, inner_d, wall_h),
-                WOOD_IDX,
-            )
-        )
-        bevel_verts.extend(
-            add_box(
-                bm,
-                (hx - WALL / 2.0, 0.0, wall_z),
-                (WALL, inner_d, wall_h),
-                WOOD_IDX,
-            )
-        )
 
-        slat_w = (OUTER_W - 0.06) / N_FRONT
-        gap = 0.006
-        usable = slat_w - gap
-        x0 = -hx + 0.03 + usable / 2.0
+        pitch = OUTER_W / N_FRONT
+        overlap = 0.006
         for i in range(N_FRONT):
-            x = x0 + i * slat_w
-            bevel_verts.extend(
+            jw = 0.004 * math.sin(i * 1.7 + 0.4)
+            x = -hx + pitch * (i + 0.5)
+            y_off = 0.0015 if (i % 2) else 0.0
+            wood.extend(
                 add_box(
                     bm,
-                    (x, -hy - SLAT_T / 2.0, wall_z),
-                    (usable, SLAT_T, wall_h - 0.02),
+                    (x, -hy + WALL / 2.0 + y_off, wall_z),
+                    (pitch + overlap + jw, WALL, wall_h),
+                    WOOD_IDX,
+                )
+            )
+            wood.extend(
+                add_box(
+                    bm,
+                    (x, hy - WALL / 2.0 - y_off, wall_z),
+                    (pitch + overlap + jw, WALL, wall_h),
                     WOOD_IDX,
                 )
             )
 
-        n_side = 3
-        side_h = (wall_h - 0.04) / n_side
+        pitch_z = wall_h / N_SIDE
+        inner_d = OUTER_D - 2.0 * WALL + 0.010
         for sign in (-1.0, 1.0):
-            for i in range(n_side):
-                z = FOOT_H + BOTTOM + 0.02 + side_h / 2.0 + i * (side_h + 0.006)
-                bevel_verts.extend(
+            for i in range(N_SIDE):
+                jh = 0.003 * math.sin(i * 1.3 + sign)
+                z = FOOT_H + BOTTOM + pitch_z * (i + 0.5)
+                x_off = 0.0015 if (i % 2) else 0.0
+                wood.extend(
                     add_box(
                         bm,
-                        (sign * (hx + SLAT_T / 2.0), 0.0, z),
-                        (SLAT_T, OUTER_D - 0.08, side_h - 0.008),
+                        (sign * (hx - WALL / 2.0 - sign * x_off), 0.0, z),
+                        (WALL, inner_d, pitch_z + 0.006 + jh),
                         WOOD_IDX,
                     )
                 )
 
+        rim_t = 0.012
+        rim_z = body_top - rim_t / 2.0 - 0.002
+        wood.extend(
+            add_box(
+                bm, (0.0, -hy + WALL + rim_t / 2.0, rim_z),
+                (OUTER_W - 2.0 * WALL, rim_t, rim_t), WOOD_IDX,
+            )
+        )
+        wood.extend(
+            add_box(
+                bm, (0.0, hy - WALL - rim_t / 2.0, rim_z),
+                (OUTER_W - 2.0 * WALL, rim_t, rim_t), WOOD_IDX,
+            )
+        )
+        wood.extend(
+            add_box(
+                bm, (-hx + WALL + rim_t / 2.0 + 0.003, 0.0, rim_z),
+                (rim_t, OUTER_D - 2.0 * WALL - 2.0 * rim_t - 0.012, rim_t), WOOD_IDX,
+            )
+        )
+        wood.extend(
+            add_box(
+                bm, (hx - WALL - rim_t / 2.0 - 0.003, 0.0, rim_z),
+                (rim_t, OUTER_D - 2.0 * WALL - 2.0 * rim_t - 0.012, rim_t), WOOD_IDX,
+            )
+        )
+
+        band_t = 0.004 if narrow_bands else BAND_T
+        band_y_off = 0.022 if narrow_bands else 0.0
         band_xs = (-OUTER_W * 0.32, 0.0, OUTER_W * 0.32)
         for bx in band_xs:
-            bevel_verts.extend(
+            metal.extend(
                 add_box(
                     bm,
-                    (bx, -hy - BAND_T / 2.0, wall_z),
-                    (BAND_W, BAND_T, wall_h + 0.01),
+                    (
+                        bx,
+                        -hy - band_t / 2.0 - band_y_off,
+                        FOOT_H + (wall_h + BOTTOM) / 2.0,
+                    ),
+                    (BAND_W, band_t, wall_h + BOTTOM + band_t),
                     METAL_IDX,
                 )
             )
-            bevel_verts.extend(
+            metal.extend(
                 add_box(
                     bm,
-                    (bx, hy + BAND_T / 2.0, wall_z),
-                    (BAND_W, BAND_T, wall_h + 0.01),
+                    (
+                        bx,
+                        hy + band_t / 2.0 + band_y_off,
+                        FOOT_H + (wall_h + BOTTOM) / 2.0,
+                    ),
+                    (BAND_W, band_t, wall_h + BOTTOM + band_t),
                     METAL_IDX,
                 )
             )
-            bevel_verts.extend(
+            metal.extend(
                 add_box(
                     bm,
-                    (bx, 0.0, FOOT_H + BAND_T / 2.0),
-                    (BAND_W, OUTER_D + 2.0 * BAND_T, BAND_T),
+                    (bx, 0.0, FOOT_H - band_t / 2.0 + 0.002),
+                    (BAND_W, OUTER_D - 0.008, band_t),
                     METAL_IDX,
                 )
             )
 
-        plate_w = 0.12
-        plate_h = 0.13
-        bevel_verts.extend(
-            add_box(
-                bm,
-                (0.0, -hy - BAND_T - 0.006, FOOT_H + BOTTOM + CAVITY_H * 0.55),
-                (plate_w, 0.014, plate_h),
-                METAL_IDX,
-            )
-        )
-        bevel_verts.extend(
-            add_box(
-                bm,
-                (0.0, -hy - BAND_T - 0.018, FOOT_H + BOTTOM + CAVITY_H * 0.70),
-                (0.036, 0.028, 0.022),
-                METAL_IDX,
-            )
-        )
-
-        bracket = 0.055
-        thick = 0.016
         for sxn in (-1.0, 1.0):
             for syn in (-1.0, 1.0):
-                bevel_verts.extend(
+                metal.extend(
                     add_box(
                         bm,
                         (
-                            sxn * (hx + thick / 2.0),
-                            syn * (hy - bracket / 2.0),
+                            sxn * (hx - BRACKET / 2.0 + 0.004),
+                            syn * (hy + IRON_T / 2.0),
                             wall_z,
                         ),
-                        (thick, bracket, wall_h - 0.02),
+                        (BRACKET - 0.010, IRON_T, wall_h - 0.020),
                         METAL_IDX,
                     )
                 )
-                bevel_verts.extend(
+                metal.extend(
                     add_box(
                         bm,
                         (
-                            sxn * (hx - bracket / 2.0),
-                            syn * (hy + thick / 2.0),
+                            sxn * (hx + IRON_T / 2.0),
+                            syn * (hy - BRACKET / 2.0 + 0.004),
                             wall_z,
                         ),
-                        (bracket, thick, wall_h - 0.02),
+                        (IRON_T, BRACKET - 0.010, wall_h - 0.020),
                         METAL_IDX,
                     )
                 )
 
-        # Closed lid, then rotate around the back hinge so the front lifts.
-        lid_z = body_top + LID_T / 2.0
-        lid_verts.extend(
+        plate_t = 0.008
+        metal.extend(
             add_box(
                 bm,
-                (0.0, 0.0, lid_z),
-                (OUTER_W, OUTER_D, LID_T),
-                WOOD_IDX,
+                (0.0, -hy - BAND_T - plate_t / 2.0, FOOT_H + BOTTOM + CAVITY_H * 0.48),
+                (0.11, plate_t, 0.12),
+                METAL_IDX,
             )
         )
-        lid_verts.extend(
-            add_box(
-                bm,
-                (0.0, -hy + LID_LIP / 2.0, body_top - LID_LIP / 2.0 + 0.004),
-                (OUTER_W - 0.02, LID_LIP, LID_LIP),
-                WOOD_IDX,
+        st_y = -hy - BAND_T - plate_t - 0.006
+        st_z = FOOT_H + BOTTOM + CAVITY_H * 0.58
+        metal.extend(add_box(bm, (-0.012, st_y, st_z), (0.008, 0.014, 0.022), METAL_IDX))
+        metal.extend(add_box(bm, (0.012, st_y, st_z), (0.008, 0.014, 0.022), METAL_IDX))
+        metal.extend(add_box(bm, (0.0, st_y, st_z + 0.012), (0.032, 0.014, 0.008), METAL_IDX))
+
+        cz = body_top - math.sqrt(max(VAULT_R * VAULT_R - hy * hy, 1e-6))
+        a_front = math.atan2(-hy, body_top - cz)
+        a_back = math.atan2(hy, body_top - cz)
+        lid_wood.extend(
+            add_arc_slab(
+                bm, cz, a_front, a_back,
+                VAULT_R, VAULT_R + LID_T,
+                -hx + 0.008, hx - 0.008,
+                10, WOOD_IDX,
             )
         )
-        lid_slat_w = (OUTER_W - 0.05) / N_LID
-        usable_l = lid_slat_w - 0.006
-        x0l = -hx + 0.025 + usable_l / 2.0
-        for i in range(N_LID):
-            x = x0l + i * lid_slat_w
-            lid_verts.extend(
+
+        n_band_seg = 8
+        bspan = (a_back - a_front) / n_band_seg
+        r_band = VAULT_R + LID_T + BAND_T / 2.0 + 0.002
+        for bx in band_xs:
+            for i in range(n_band_seg):
+                tmid = a_front + (i + 0.5) * bspan
+                y = r_band * math.sin(tmid)
+                z = cz + r_band * math.cos(tmid)
+                chord = r_band * bspan + 0.003
+                lid_metal.extend(
+                    add_box(
+                        bm, (bx, y, z),
+                        (BAND_W, chord, BAND_T),
+                        METAL_IDX, euler=(tmid, 0.0, 0.0),
+                    )
+                )
+            tmid = a_front
+            y = r_band * math.sin(tmid)
+            z = cz + r_band * math.cos(tmid)
+            lid_metal.extend(
                 add_box(
-                    bm,
-                    (x, 0.0, body_top + LID_T + SLAT_T / 2.0),
-                    (usable_l, OUTER_D - 0.04, SLAT_T),
-                    WOOD_IDX,
+                    bm, (bx, y - 0.008, z - 0.006),
+                    (BAND_W, BAND_T, LID_T + 0.016),
+                    METAL_IDX, euler=(tmid, 0.0, 0.0),
                 )
             )
-        for bx in band_xs:
-            lid_verts.extend(
+
+        tmid = a_front
+        r_hasp = VAULT_R + LID_T + 0.006
+        y = r_hasp * math.sin(tmid)
+        z = cz + r_hasp * math.cos(tmid)
+        lid_metal.extend(
+            add_box(
+                bm, (0.0, y - 0.018, z - 0.010),
+                (0.038, 0.010, 0.055),
+                METAL_IDX, euler=(tmid, 0.0, 0.0),
+            )
+        )
+
+        knuckle_verts = []
+        for hx_i in (-OUTER_W * 0.28, OUTER_W * 0.28):
+            metal.extend(
                 add_box(
-                    bm,
-                    (bx, 0.0, body_top + LID_T + SLAT_T + BAND_T / 2.0),
-                    (BAND_W, OUTER_D + 2.0 * BAND_T, BAND_T),
-                    METAL_IDX,
+                    bm, (hx_i, hy + HINGE_R * 0.15, body_top),
+                    (0.050, 0.022, 0.022), METAL_IDX,
                 )
             )
-            lid_verts.extend(
+            lid_metal.extend(
                 add_box(
-                    bm,
-                    (bx, -hy - BAND_T / 2.0, body_top + LID_T / 2.0),
-                    (BAND_W, BAND_T, LID_T + SLAT_T + 0.01),
-                    METAL_IDX,
+                    bm, (hx_i, hy - 0.016, body_top + 0.006),
+                    (0.036, 0.040, 0.008), METAL_IDX,
                 )
             )
-        lid_verts.extend(
-            add_box(
-                bm,
-                (0.0, -hy - BAND_T - 0.006, body_top + 0.012),
-                (0.055, 0.016, 0.028),
-                METAL_IDX,
+            # Short lid knuckles over the barrels, not a spanning stile.
+            # A full-width stile only has verts at the X ends, 8 cm from
+            # the barrels, so a BVH join against it is a false gap.
+            kv = add_box(
+                bm, (hx_i, hy + 0.002, body_top + 0.012),
+                (0.070, 0.028, 0.016), WOOD_IDX,
             )
-        )
+            lid_wood.extend(kv)
+            knuckle_verts.extend(kv)
 
         hinge = Vector((0.0, hy, body_top))
         rot = Euler((LID_ANGLE, 0.0, 0.0)).to_matrix()
-        for v in lid_verts:
+        for v in lid_wood + lid_metal:
             v.co = rot @ (v.co - hinge) + hinge
+        if float_hinge:
+            # Lift knuckles off the barrels without swinging the vault
+            # past the declared AABB (a shifted rotation pivot did).
+            for v in knuckle_verts:
+                v.co.z += 0.08
 
+        bevel_verts = wood + knuckle_verts
         if bevel_offset > 0.0:
-            edges = list(
-                {e for v in (bevel_verts + lid_verts) for e in v.link_edges}
-            )
+            edges = list({e for v in bevel_verts for e in v.link_edges})
             bmesh.ops.bevel(
                 bm,
                 geom=edges,
@@ -404,6 +493,16 @@ def build_chest_mesh(name, bevel_offset, bevel_segments):
                 affect="EDGES",
                 clamp_overlap=True,
             )
+            for v in bevel_verts:
+                if not v.is_valid:
+                    continue
+                for f in v.link_faces:
+                    f.material_index = WOOD_IDX
+        for v in metal + lid_metal:
+            if not v.is_valid:
+                continue
+            for f in v.link_faces:
+                f.material_index = METAL_IDX
 
         xs = [v.co.x for v in bm.verts]
         ys = [v.co.y for v in bm.verts]
@@ -437,19 +536,37 @@ def build_chest_mesh(name, bevel_offset, bevel_segments):
     return obj
 
 
-def principled(name, color, metallic, roughness):
+def principled(name, color, metallic, roughness, noise_scale=0.0, wear=None):
     mat = bpy.data.materials.new(name)
     mat.use_nodes = True
-    bsdf = mat.node_tree.nodes["Principled BSDF"]
+    nt = mat.node_tree
+    bsdf = nt.nodes["Principled BSDF"]
     bsdf.inputs["Base Color"].default_value = color
     bsdf.inputs["Metallic"].default_value = metallic
     bsdf.inputs["Roughness"].default_value = roughness
+    if noise_scale > 0.0 and wear is not None:
+        tex = nt.nodes.new("ShaderNodeTexNoise")
+        tex.inputs["Scale"].default_value = noise_scale
+        tex.inputs["Detail"].default_value = 8.0
+        tex.inputs["Roughness"].default_value = 0.55
+        mix = nt.nodes.new("ShaderNodeMix")
+        mix.data_type = "RGBA"
+        mix.inputs["A"].default_value = color
+        mix.inputs["B"].default_value = wear
+        fac = mix.inputs.get("Factor") or mix.inputs.get("Fac")
+        nt.links.new(tex.outputs["Fac"], fac)
+        nt.links.new(mix.outputs["Result"], bsdf.inputs["Base Color"])
+        rmix = nt.nodes.new("ShaderNodeMix")
+        rmix.data_type = "FLOAT"
+        rmix.inputs["A"].default_value = roughness
+        rmix.inputs["B"].default_value = min(1.0, roughness + 0.18)
+        rfac = rmix.inputs.get("Factor") or rmix.inputs.get("Fac")
+        nt.links.new(tex.outputs["Fac"], rfac)
+        nt.links.new(rmix.outputs["Result"], bsdf.inputs["Roughness"])
     return mat
 
 
 def assign_slots(obj, wood, metal):
-    # Do not materials.clear() — that resets polygon material_index to 0
-    # on this Blender, which would drop metal faces onto wood.
     mats = obj.data.materials
     wanted = (wood, metal)
     for i, mat in enumerate(wanted):
@@ -492,6 +609,260 @@ def uv_stats(mesh):
     return min(us), min(vs), max(us), max(vs), overlap, len(aabbs)
 
 
+def face_area(me, poly):
+    idxs = poly.vertices
+    if len(idxs) < 3:
+        return 0.0
+    v0 = me.vertices[idxs[0]].co
+    area = 0.0
+    for i in range(1, len(idxs) - 1):
+        vs = (me.vertices[idxs[i]].co, me.vertices[idxs[i + 1]].co)
+        area += (vs[0] - v0).cross(vs[1] - v0).length * 0.5
+    return area
+
+
+def hygiene_audit(me):
+    nv, ne, nf = len(me.vertices), len(me.edges), len(me.polygons)
+    ngons = sum(1 for p in me.polygons if len(p.vertices) > 4)
+    zero_area = sum(1 for p in me.polygons if face_area(me, p) <= AREA_EPS)
+    bm = bmesh.new()
+    try:
+        bm.from_mesh(me)
+        bm.verts.ensure_lookup_table()
+        bm.edges.ensure_lookup_table()
+        loose_v = sum(1 for v in bm.verts if len(v.link_edges) == 0)
+        loose_e = sum(1 for e in bm.edges if len(e.link_faces) == 0)
+        nonman = sum(1 for e in bm.edges if not e.is_manifold)
+        ret = bmesh.ops.find_doubles(bm, verts=list(bm.verts), dist=DOUBLES_EPS)
+        doubles = len(ret.get("targetmap") or {})
+    finally:
+        bm.free()
+    return {
+        "nv": nv, "ne": ne, "nf": nf, "ngons": ngons,
+        "loose_v": loose_v, "loose_e": loose_e, "nonman": nonman,
+        "zero_area": zero_area, "doubles": doubles, "euler": nv - ne + nf,
+    }
+
+
+def zfight_pairs(me):
+    data = [
+        (p.center.copy(), p.normal.copy(), frozenset(p.vertices))
+        for p in me.polygons
+    ]
+    eps2 = ZFIGHT_EPS * ZFIGHT_EPS
+    count = 0
+    for i in range(len(data)):
+        ci, ni, vi = data[i]
+        for j in range(i + 1, len(data)):
+            cj, nj, vj = data[j]
+            if (cj - ci).length_squared > eps2:
+                continue
+            if abs(ni.dot(nj)) <= ZFIGHT_COS:
+                continue
+            if vi & vj:
+                continue
+            count += 1
+    return count
+
+
+def shells(me):
+    neighbors = [[] for _ in range(len(me.vertices))]
+    for edge in me.edges:
+        a, b = edge.vertices
+        neighbors[a].append(b)
+        neighbors[b].append(a)
+    seen = [False] * len(me.vertices)
+    groups = []
+    for start in range(len(me.vertices)):
+        if seen[start]:
+            continue
+        seen[start] = True
+        stack = [start]
+        group = []
+        while stack:
+            current = stack.pop()
+            group.append(current)
+            for nxt in neighbors[current]:
+                if not seen[nxt]:
+                    seen[nxt] = True
+                    stack.append(nxt)
+        groups.append(group)
+    return groups
+
+
+def shell_aabb(me, group):
+    pts = [me.vertices[i].co for i in group]
+    return (
+        min(p.x for p in pts), min(p.y for p in pts), min(p.z for p in pts),
+        max(p.x for p in pts), max(p.y for p in pts), max(p.z for p in pts),
+    )
+
+
+def mat_of(me, group):
+    member = set(group)
+    for p in me.polygons:
+        if all(i in member for i in p.vertices):
+            return p.material_index
+    return None
+
+
+def support_audit(me):
+    groups = shells(me)
+    feet = []
+    for g in groups:
+        if mat_of(me, g) != WOOD_IDX:
+            continue
+        a = shell_aabb(me, g)
+        dx, dy, dz = a[3] - a[0], a[4] - a[1], a[5] - a[2]
+        if a[5] < 0.10 and dx < 0.12 and dy < 0.12 and dz > 0.03:
+            feet.append(a)
+    foot_z = min((a[2] for a in feet), default=99.0)
+    return {"feet": len(feet), "foot_z": foot_z}
+
+
+def body_audit(me):
+    groups = shells(me)
+    best = None
+    best_area = -1.0
+    for g in groups:
+        if mat_of(me, g) != WOOD_IDX:
+            continue
+        a = shell_aabb(me, g)
+        dx, dy = a[3] - a[0], a[4] - a[1]
+        if dx > 0.50 and dy > 0.30 and a[2] < 0.12:
+            area = dx * dy
+            if area > best_area:
+                best_area = area
+                best = a
+    if best is None:
+        return {"w": 0.0, "d": 0.0}
+    return {"w": best[3] - best[0], "d": best[4] - best[1]}
+
+
+def hinge_join(me):
+    """Gap from lid knuckles to the hinge barrels.
+
+    Barrels are compact metal at the back rim. Knuckles are compact wood
+    at the same station. Lock-plate staples, lid-band caps, and the
+    hasp must not enter this set — they sit on the front of the chest.
+    """
+    groups = shells(me)
+    hinges = []
+    lid_wood = []
+    for g in groups:
+        a = shell_aabb(me, g)
+        m = mat_of(me, g)
+        dx, dy, dz = a[3] - a[0], a[4] - a[1], a[5] - a[2]
+        back_rim = a[1] > 0.15 and a[2] > 0.30
+        if (
+            m == METAL_IDX and back_rim
+            and 0.03 < dx < 0.08 and 0.015 < dy < 0.040 and 0.015 < dz < 0.040
+        ):
+            hinges.append(g)
+        if (
+            m == WOOD_IDX and back_rim
+            and 0.04 < dx < 0.12 and dy < 0.05 and dz < 0.04
+        ):
+            lid_wood.append(g)
+    if not hinges or not lid_wood:
+        return 99.0
+    bm_h = bmesh.new()
+    try:
+        bm_h.from_mesh(me)
+        keep = set()
+        for g in hinges:
+            keep.update(g)
+        drop = [
+            f for f in bm_h.faces
+            if not all(v.index in keep for v in f.verts)
+        ]
+        if drop:
+            bmesh.ops.delete(bm_h, geom=drop, context="FACES")
+        if not bm_h.faces:
+            return 99.0
+        tree = BVHTree.FromBMesh(bm_h)
+        best = 99.0
+        for g in lid_wood:
+            for i in g:
+                hit = tree.find_nearest(me.vertices[i].co)
+                if hit[0] is None:
+                    continue
+                best = min(best, hit[3])
+        return best
+    finally:
+        bm_h.free()
+
+
+def band_wall_gap(me):
+    """Worst gap from a vertical iron band to wood.
+
+    Overlap counts as 0. ``--narrow-bands`` floats the straps off the
+    slats so this goes positive.
+    """
+    groups = shells(me)
+    bands = []
+    for g in groups:
+        if mat_of(me, g) != METAL_IDX:
+            continue
+        a = shell_aabb(me, g)
+        dx, dy, dz = a[3] - a[0], a[4] - a[1], a[5] - a[2]
+        if dz > 0.15 and dx < 0.10 and dy < 0.08:
+            bands.append(g)
+    if not bands:
+        return 99.0
+    bm_wood = bmesh.new()
+    try:
+        bm_wood.from_mesh(me)
+        drop = [f for f in bm_wood.faces if f.material_index != WOOD_IDX]
+        if drop:
+            bmesh.ops.delete(bm_wood, geom=drop, context="FACES")
+        if not bm_wood.faces:
+            return 99.0
+        tree_wood = BVHTree.FromBMesh(bm_wood)
+        worst = 0.0
+        for g in bands:
+            bm_s = bmesh.new()
+            try:
+                bm_s.from_mesh(me)
+                member = set(g)
+                drop_s = [
+                    f for f in bm_s.faces
+                    if not all(v.index in member for v in f.verts)
+                ]
+                if drop_s:
+                    bmesh.ops.delete(bm_s, geom=drop_s, context="FACES")
+                if not bm_s.faces:
+                    worst = max(worst, 99.0)
+                    continue
+                tree_s = BVHTree.FromBMesh(bm_s)
+                if tree_wood.overlap(tree_s):
+                    continue
+                best = 99.0
+                for i in g:
+                    hit = tree_wood.find_nearest(me.vertices[i].co)
+                    if hit[0] is None:
+                        continue
+                    best = min(best, hit[3])
+                if best > worst:
+                    worst = best
+            finally:
+                bm_s.free()
+        return worst
+    finally:
+        bm_wood.free()
+
+
+def add_stray_vert(me):
+    bm = bmesh.new()
+    try:
+        bm.from_mesh(me)
+        bm.verts.new((0.0, 0.0, 0.40))
+        bm.to_mesh(me)
+        me.update()
+    finally:
+        bm.free()
+
+
 def make_lod(obj, name, ratio, skip_decimate):
     mesh = obj.data.copy()
     lod = bpy.data.objects.new(name, mesh)
@@ -505,7 +876,6 @@ def make_lod(obj, name, ratio, skip_decimate):
 
 
 def convex_hull_collider(obj, name):
-    # Duplicated from snippets/convex_hull_collider.py (not a package).
     mesh = bpy.data.meshes.new(name)
     bm = bmesh.new()
     try:
@@ -528,7 +898,6 @@ def convex_hull_collider(obj, name):
 
 
 def setup_bake_image(obj, target_mat, size=BAKE_RES):
-    # Adapted from snippets/setup_bake_target_image.py — do not replace slots.
     if not obj.data.uv_layers:
         return None, None
     img = bpy.data.images.new("ChestNrm", size, size, alpha=True, float_buffer=False)
@@ -543,7 +912,6 @@ def setup_bake_image(obj, target_mat, size=BAKE_RES):
 
 
 def bake_normal(high, low):
-    # Duplicated from snippets/bake_normal_high_to_low.py (not a package).
     scene = bpy.context.scene
     scene.render.engine = "CYCLES"
     scene.cycles.device = "CPU"
@@ -568,7 +936,6 @@ def bake_normal(high, low):
 
 
 def export_unity(path, objects):
-    # Duplicated from snippets/export_preset_unity.py (not a package).
     for ob in bpy.context.view_layer.objects:
         ob.select_set(False)
     for ob in objects:
@@ -584,14 +951,33 @@ def export_unity(path, objects):
     )
 
 
-def check(skip_decimate):
+def check(
+    skip_decimate, lift_z=False, stray_vert=False,
+    short_legs=False, float_hinge=False, narrow_bands=False,
+):
     bpy.ops.wm.read_factory_settings(use_empty=True)
-    low = build_chest_mesh("ChestLow", bevel_offset=0.008, bevel_segments=2)
-    high = build_chest_mesh("ChestHigh", bevel_offset=0.008, bevel_segments=4)
-    wood = principled("ChestWood", (0.42, 0.20, 0.07, 1.0), 0.0, 0.52)
-    metal = principled("ChestMetal", (0.22, 0.23, 0.26, 1.0), 1.0, 0.30)
+    flags = dict(
+        short_legs=short_legs, float_hinge=float_hinge, narrow_bands=narrow_bands,
+    )
+    low = build_chest_mesh("ChestLow", 0.003, 2, **flags)
+    high = build_chest_mesh("ChestHigh", 0.003, 4, **flags)
+    wood = principled(
+        "ChestWood", (0.40, 0.18, 0.06, 1.0), 0.0, 0.54,
+        noise_scale=6.5, wear=(0.22, 0.10, 0.04, 1.0),
+    )
+    metal = principled(
+        "ChestMetal", (0.18, 0.19, 0.22, 1.0), 1.0, 0.32,
+        noise_scale=5.0, wear=(0.08, 0.08, 0.09, 1.0),
+    )
     assign_slots(low, wood, metal)
     assign_slots(high, wood, metal)
+    if stray_vert:
+        add_stray_vert(low.data)
+    if lift_z:
+        for v in low.data.vertices:
+            v.co.z += LIFT_Z
+        low.data.update()
+        bpy.context.view_layer.update()
 
     if low.data is None or len(low.data.polygons) < 6:
         return fail("chest mesh did not build", 3), None, None, None, None, None
@@ -623,9 +1009,7 @@ def check(skip_decimate):
     r1 = lod1_tris / base_tris if base_tris else 0.0
     r2 = lod2_tris / base_tris if base_tris else 0.0
 
-    collider_src = build_chest_mesh(
-        "ChestColSrc", bevel_offset=0.0, bevel_segments=1
-    )
+    collider_src = build_chest_mesh("ChestColSrc", 0.0, 1, **flags)
     collider = convex_hull_collider(collider_src, "ChestCollider")
     bpy.data.objects.remove(collider_src, do_unlink=True)
     col_tris = triangle_count(collider.data)
@@ -639,9 +1023,14 @@ def check(skip_decimate):
     export_unity(export_path, [low, collider])
     export_size = os.path.getsize(export_path) if os.path.isfile(export_path) else 0
 
-    print(
-        f"blender={tuple(bpy.app.version)} skip_decimate={skip_decimate}"
-    )
+    hyg = hygiene_audit(low.data)
+    zf = zfight_pairs(low.data)
+    sup = support_audit(low.data)
+    body = body_audit(low.data)
+    hj = hinge_join(low.data)
+    bg = band_wall_gap(low.data)
+
+    print(f"blender={tuple(bpy.app.version)} skip_decimate={skip_decimate}")
     print(
         f"measured base_tris={base_tris} lod1_tris={lod1_tris} "
         f"lod2_tris={lod2_tris} r1={r1:.4f} r2={r2:.4f}"
@@ -658,6 +1047,16 @@ def check(skip_decimate):
         f"measured collider_tris={col_tris} bake={bake_result} "
         f"bake_has_data={img.has_data} export_bytes={export_size}"
     )
+    print(
+        f"measured hygiene loose_v={hyg['loose_v']} loose_e={hyg['loose_e']} "
+        f"nonman={hyg['nonman']} zero_area={hyg['zero_area']} "
+        f"doubles={hyg['doubles']} ngons={hyg['ngons']} zfight={zf}"
+    )
+    print(
+        f"measured supports feet={sup['feet']} foot_z={sup['foot_z']:.5f} "
+        f"body_w={body['w']:.4f} body_d={body['d']:.4f} "
+        f"hinge_join={hj:.5f} band_gap={bg:.5f}"
+    )
 
     if not (BASE_TRIS_MIN <= base_tris <= BASE_TRIS_MAX):
         return fail(
@@ -674,6 +1073,11 @@ def check(skip_decimate):
             f"metal faces {idx_counts.get(METAL_IDX, 0)} < {METAL_FACES_MIN}",
             5,
         ), None, None, None, None, None
+    if idx_counts.get(WOOD_IDX, 0) < WOOD_FACES_MIN:
+        return fail(
+            f"wood faces {idx_counts.get(WOOD_IDX, 0)} < {WOOD_FACES_MIN}",
+            5,
+        ), None, None, None, None, None
     if u0 < -UV_EPS or v0 < -UV_EPS or u1 > 1.0 + UV_EPS or v1 > 1.0 + UV_EPS:
         return fail(
             f"UVs outside 0..1: ({u0:.4f},{v0:.4f})-({u1:.4f},{v1:.4f})",
@@ -717,6 +1121,50 @@ def check(skip_decimate):
         ), None, None, None, None, None
     if export_size <= 0:
         return fail("export file missing or empty", 13), None, None, None, None, None
+    if (
+        hyg["loose_v"] or hyg["loose_e"] or hyg["nonman"]
+        or hyg["zero_area"] or hyg["doubles"] or hyg["ngons"] or zf
+    ):
+        return fail(
+            f"hygiene loose_v={hyg['loose_v']} loose_e={hyg['loose_e']} "
+            f"nonman={hyg['nonman']} zero_area={hyg['zero_area']} "
+            f"doubles={hyg['doubles']} ngons={hyg['ngons']} zfight={zf}",
+            15,
+        ), None, None, None, None, None
+    if abs(bb[2]) > ZMIN_EPS:
+        return fail(
+            f"zmin {bb[2]:.6f} not within {ZMIN_EPS} of 0 "
+            "(--lift-z is the designed fail)",
+            16,
+        ), None, None, None, None, None
+    if sup["feet"] < 4 or sup["foot_z"] > FOOT_Z_MAX:
+        return fail(
+            f"foot supports {sup['feet']} foot_z={sup['foot_z']:.5f} "
+            "(--short-legs is the designed fail)",
+            16,
+        ), None, None, None, None, None
+    if hj > HINGE_JOIN:
+        return fail(
+            f"lid-hinge gap {hj:.5f} > {HINGE_JOIN} "
+            "(--float-hinge is the designed fail)",
+            17,
+        ), None, None, None, None, None
+    if bg > BAND_SEAT:
+        return fail(
+            f"band-wall gap {bg:.5f} > {BAND_SEAT} "
+            "(--narrow-bands is the designed fail)",
+            18,
+        ), None, None, None, None, None
+    if abs(body["w"] - BODY_W) > BODY_W_TOL:
+        return fail(
+            f"body width {body['w']:.4f} off {BODY_W}",
+            19,
+        ), None, None, None, None, None
+    if abs(body["d"] - BODY_D) > BODY_D_TOL:
+        return fail(
+            f"body depth {body['d']:.4f} off {BODY_D}",
+            19,
+        ), None, None, None, None, None
     return 0, low, high, wood, tex, collider
 
 
@@ -784,10 +1232,10 @@ def light(name, loc, energy, size, col, rot):
     cam_data = bpy.data.cameras.new("Cam")
     cam_data.lens = 50.0
     cam = bpy.data.objects.new("Cam", cam_data)
-    cam.location = (1.54, -2.16, 1.37)
+    cam.location = (1.62, -2.22, 1.42)
     scene.collection.objects.link(cam)
     aim = bpy.data.objects.new("Aim", None)
-    aim.location = (0.0, 0.0, 0.34)
+    aim.location = (0.0, 0.0, 0.36)
     scene.collection.objects.link(aim)
     con = cam.constraints.new("TRACK_TO")
     con.target = aim
@@ -830,14 +1278,22 @@ def main():
     p = argparse.ArgumentParser()
     p.add_argument("--output", default=None)
     p.add_argument("--engine", default="eevee", choices=("eevee", "cycles"))
-    p.add_argument(
-        "--skip-decimate",
-        action="store_true",
-        help="falsification: skip the LOD DECIMATE stage",
-    )
+    p.add_argument("--skip-decimate", action="store_true")
+    p.add_argument("--lift-z", action="store_true")
+    p.add_argument("--stray-vert", action="store_true")
+    p.add_argument("--short-legs", action="store_true")
+    p.add_argument("--float-hinge", action="store_true")
+    p.add_argument("--narrow-bands", action="store_true")
     args = p.parse_args(argv)
 
-    code, low, _high, wood, tex, _col = check(args.skip_decimate)
+    code, low, _high, wood, tex, _col = check(
+        args.skip_decimate,
+        lift_z=args.lift_z,
+        stray_vert=args.stray_vert,
+        short_legs=args.short_legs,
+        float_hinge=args.float_hinge,
+        narrow_bands=args.narrow_bands,
+    )
     if code:
         return code
     if args.output: