diff --git a/README.md b/README.md
index e63f879..bc8fc3d 100644
--- a/README.md
+++ b/README.md
@@ -81,7 +81,7 @@ Budget-conformance props. Not examples. Conventions: [`showcase/README.md`](show
 <p align="center">
   <a href="showcase/shipping-crate/"><img src="showcase/shipping-crate/preview.webp" width="24%" alt="Shipping crate: a wooden slat crate with iron corner brackets on a dark studio floor, warm wedge on the back wall" /></a>
   <a href="showcase/stone-well/"><img src="showcase/stone-well/preview.webp" width="24%" alt="Stone well: a round brick well with a shingled pyramid roof on posts, rope and bucket, on a dark studio floor" /></a>
-  <a href="showcase/wooden-barrel/"><img src="showcase/wooden-barrel/preview.webp" width="24%" alt="Wooden barrel: a staved barrel with iron hoops on a dark studio floor, warm wedge on the back wall" /></a>
+  <a href="showcase/wooden-barrel/"><img src="showcase/wooden-barrel/preview.webp" width="24%" alt="Wooden barrel: a 20-stave wine-cask with croze-seated heads, chord-lofted iron hoops, and a bung on a dark studio floor" /></a>
   <a href="showcase/campfire/"><img src="showcase/campfire/preview.webp" width="24%" alt="Campfire: a two-course stone fire ring with a tripod of logs on a dark studio floor, warm wedge on the back wall" /></a>
   <a href="showcase/market-stall/"><img src="showcase/market-stall/preview.webp" width="24%" alt="Market stall: a timber frame with post feet, slatted counter, rafters, and a striped awning on a dark studio floor, warm wedge on the back wall" /></a>
   <a href="showcase/street-lantern/"><img src="showcase/street-lantern/preview.webp" width="24%" alt="Street lantern: an iron post with brass collars, a braced arm, and a muntined amber cage on a dark studio floor" /></a>
@@ -99,7 +99,7 @@ Budget-conformance props. Not examples. Conventions: [`showcase/README.md`](show
   <a href="showcase/hand-pump/"><img src="showcase/hand-pump/preview.webp" width="24%" alt="Hand pump: a cast-iron village pump on a wooden plinth with a spout and handle on a dark studio floor" /></a>
   <a href="showcase/signpost/"><img src="showcase/signpost/preview.webp" width="24%" alt="Signpost: a timber post with two painted fingerboards, iron straps, and a pyramidal cap on a dark studio floor" /></a>
   <a href="showcase/chopping-block/"><img src="showcase/chopping-block/preview.webp" width="24%" alt="Chopping block: a hooped timber stump with an embedded axe on a dark studio floor" /></a>
-  <a href="showcase/wooden-bucket/"><img src="showcase/wooden-bucket/preview.webp" width="24%" alt="Wooden bucket: a coopered bucket with overlapping staves, iron hoops, and a rope bail on a dark studio floor" /></a>
+  <a href="showcase/wooden-bucket/"><img src="showcase/wooden-bucket/preview.webp" width="24%" alt="Wooden bucket: a coopered pail with a round rope bail through ear rings and chord-lofted iron hoops on a dark studio floor" /></a>
   <a href="showcase/wall-torch/"><img src="showcase/wall-torch/preview.webp" width="24%" alt="Wall torch: a dressed stone plaque with an iron sconce, wooden haft, and flame on a dark studio floor" /></a>
   <a href="showcase/tavern-stool/"><img src="showcase/tavern-stool/preview.webp" width="24%" alt="Tavern stool: a round wooden seat on turned splayed legs with stretchers and iron ferrules on a dark studio floor" /></a>
   <a href="showcase/iron-cauldron/"><img src="showcase/iron-cauldron/preview.webp" width="24%" alt="Iron cauldron: a bulged iron pot hanging from a timber tripod on a dark studio floor" /></a>
@@ -111,7 +111,7 @@ Budget-conformance props. Not examples. Conventions: [`showcase/README.md`](show
 
 [`stone-well`](showcase/stone-well/) — procedural round stone well, shingled roof, windlass, rope and bucket through the same pipeline. Falsifier `--skip-decimate` exits 9.
 
-[`wooden-barrel`](showcase/wooden-barrel/) — procedural staved barrel with iron hoops through the same pipeline. Falsifier `--skip-decimate` exits 9.
+[`wooden-barrel`](showcase/wooden-barrel/) — procedural 20-stave wine-cask with croze-seated heads and chord-lofted hoops through the same pipeline. Falsifier `--round-band` exits 18.
 
 [`campfire`](showcase/campfire/) — procedural cobble ring, logs, and ash through the same pipeline. Falsifier `--skip-decimate` exits 9.
 
@@ -147,7 +147,7 @@ Budget-conformance props. Not examples. Conventions: [`showcase/README.md`](show
 
 [`chopping-block`](showcase/chopping-block/) — procedural hooped timber stump with an embedded axe through the same pipeline. Falsifier `--skip-decimate` exits 9.
 
-[`wooden-bucket`](showcase/wooden-bucket/) — procedural coopered wooden bucket with iron hoops and a rope bail through the same pipeline. Falsifier `--skip-decimate` exits 9.
+[`wooden-bucket`](showcase/wooden-bucket/) — procedural coopered pail with a round bail through the ear rings through the same pipeline. Falsifier `--float-handle` exits 17.
 
 [`wall-torch`](showcase/wall-torch/) — procedural wall-mounted torch sconce with a stone plaque, iron bracket, and flame through the same pipeline. Falsifier `--skip-decimate` exits 9.
 
diff --git a/docs/gallery/assets/wooden-barrel-hero.webp b/docs/gallery/assets/wooden-barrel-hero.webp
index 15b1521..93a87ed 100644
Binary files a/docs/gallery/assets/wooden-barrel-hero.webp and b/docs/gallery/assets/wooden-barrel-hero.webp differ
diff --git a/docs/gallery/assets/wooden-bucket-hero.webp b/docs/gallery/assets/wooden-bucket-hero.webp
index 9c1133d..a4c5d2c 100644
Binary files a/docs/gallery/assets/wooden-bucket-hero.webp and b/docs/gallery/assets/wooden-bucket-hero.webp differ
diff --git a/docs/gallery/index.html b/docs/gallery/index.html
index fbf6b53..1fe083e 100644
--- a/docs/gallery/index.html
+++ b/docs/gallery/index.html
@@ -909,12 +909,12 @@ <h2><a href="stone-well/">stone-well</a></h2>
       </article>
       <article class="card" data-tags="mesh export showcase">
         <a class="card-media" href="wooden-barrel/" aria-label="wooden-barrel example detail page">
-          <img src="assets/wooden-barrel-hero.webp" alt="wooden-barrel — A procedural staved barrel through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." loading="lazy" decoding="async" />
+          <img src="assets/wooden-barrel-hero.webp" alt="wooden-barrel — A procedural wine-cask with croze-seated heads and chord-lofted hoops through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather…" loading="lazy" decoding="async" />
         </a>
         <div class="card-body">
           <h2><a href="wooden-barrel/">wooden-barrel</a></h2>
-          <p class="teaches">A procedural staved barrel 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: 4312 tris, two materials with 88 metal hoop faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.719×0.719×0.880 m, LOD ratios in band, convex collider 372 tris, non-empty glTF. --skip-decimate exits 9 on the LOD1 ratio budget.</p>
+          <p class="teaches">A procedural wine-cask with croze-seated heads and chord-lofted hoops 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: 7216 tris, two materials with 2512 wood and 1440 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.722×0.714×0.880 m, 20 grounded staves, hoop bite 0.003 m, head-croze gap 0.007 m, LOD ratios in band, convex collider 238 tris, non-empty glTF. --skip-decimate exits 9; --round-band exits 18 on the hoop-seat budget.</p>
           <a class="card-link" href="wooden-barrel/">View example <span aria-hidden="true">&rarr;</span></a>
         </div>
       </article>
@@ -1107,12 +1107,12 @@ <h2><a href="chopping-block/">chopping-block</a></h2>
       </article>
       <article class="card" data-tags="mesh export showcase">
         <a class="card-media" href="wooden-bucket/" aria-label="wooden-bucket example detail page">
-          <img src="assets/wooden-bucket-hero.webp" alt="wooden-bucket — A procedural coopered wooden bucket with overlapping staves, a sealed bottom, iron hoops, and a rope bail through UVs, bake, LOD, collider, and Unity glTF…" loading="lazy" decoding="async" />
+          <img src="assets/wooden-bucket-hero.webp" alt="wooden-bucket — A procedural coopered pail with a croze-seated floor, chord-lofted hoops, and a round bail through the ear rings through UVs, bake, LOD, collider, and Unity…" loading="lazy" decoding="async" />
         </a>
         <div class="card-body">
           <h2><a href="wooden-bucket/">wooden-bucket</a></h2>
-          <p class="teaches">A procedural coopered wooden bucket with overlapping staves, a sealed bottom, iron hoops, and a rope bail 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: 4272 tris, three materials with 222 metal and 72 rope faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.402×0.345×0.544 m, LOD ratios in band, convex collider 390 tris, non-empty glTF. --skip-decimate exits 9 on the LOD1 ratio budget.</p>
+          <p class="teaches">A procedural coopered pail with a croze-seated floor, chord-lofted hoops, and a round bail through the ear rings through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.</p>
+          <p class="witnesses"><span class="tag">witnesses</span> Recomputed: 4872 tris, three materials with 1424 wood, 1020 metal, and 208 rope faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.383×0.346×0.527 m, 16 grounded staves, hoop bite 0.0025 m, bail-ear gap 0.0013 m, LOD ratios in band, convex collider 302 tris, non-empty glTF. --skip-decimate exits 9; --float-handle exits 17 on the bail-ear budget.</p>
           <a class="card-link" href="wooden-bucket/">View example <span aria-hidden="true">&rarr;</span></a>
         </div>
       </article>
diff --git a/docs/gallery/wooden-barrel/index.html b/docs/gallery/wooden-barrel/index.html
index 760bc56..00d0ed5 100644
--- a/docs/gallery/wooden-barrel/index.html
+++ b/docs/gallery/wooden-barrel/index.html
@@ -4,18 +4,18 @@
   <meta charset="utf-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1" />
   <title>wooden-barrel — Examples — Blender Developer Tools</title>
-  <meta name="description" content="A procedural staved barrel through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
+  <meta name="description" content="A procedural wine-cask with croze-seated heads and chord-lofted hoops through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
   <link rel="canonical" href="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/wooden-barrel/" />
   <link rel="icon" href="../../assets/favicon.svg" type="image/svg+xml" />
   <meta name="theme-color" content="#1a1b1e" />
   <meta property="og:type" content="website" />
   <meta property="og:title" content="wooden-barrel — Examples — Blender Developer Tools" />
-  <meta property="og:description" content="A procedural staved barrel through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
+  <meta property="og:description" content="A procedural wine-cask with croze-seated heads and chord-lofted hoops through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
   <meta property="og:url" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/wooden-barrel/" />
   <meta property="og:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/wooden-barrel-hero.webp" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="wooden-barrel — Examples — Blender Developer Tools" />
-  <meta name="twitter:description" content="A procedural staved barrel through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
+  <meta name="twitter:description" content="A procedural wine-cask with croze-seated heads and chord-lofted hoops through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
   <meta name="twitter:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/wooden-barrel-hero.webp" />
   <style>
     /* fonts are deployed by the landing build (docs/fonts/) */
@@ -246,35 +246,49 @@
   </div>
   <header class="hero">
     <h1>wooden-barrel</h1>
-    <p>A procedural staved barrel through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.</p>
+    <p>A procedural wine-cask with croze-seated heads and chord-lofted hoops through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.</p>
   </header>
   <main id="main">
     <button class="detail-hero" id="heroZoom" type="button" aria-label="Zoom wooden-barrel render">
       <img src="../assets/wooden-barrel-hero.webp" alt="wooden-barrel 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: 4312 tris, two materials with 88 metal hoop faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.719×0.719×0.880 m, LOD ratios in band, convex collider 372 tris, non-empty glTF. --skip-decimate exits 9 on the LOD1 ratio budget.</div>
+    <div class="callout"><span class="tag">witnesses</span> Recomputed: 7216 tris, two materials with 2512 wood and 1440 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.722×0.714×0.880 m, 20 grounded staves, hoop bite 0.003 m, head-croze gap 0.007 m, LOD ratios in band, convex collider 238 tris, non-empty glTF. --skip-decimate exits 9; --round-band exits 18 on the hoop-seat budget.</div>
     <div class="runline">
       <pre id="runCmd">blender --background --python showcase/wooden-barrel/wooden_barrel.py --</pre>
       <button class="copy-btn" id="copyRun" type="button">Copy</button>
     </div>
     <section class="detail-section md">
-<p>A showcase piece, not an example. Procedural staved barrel (bulged staves, four iron hoops, top and bottom heads) 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 wine-cask (20 staves with seeded width jitter, heads seated in a croze below a chime, iron hoops lofted on the stave faces, a bung) then the shipped pipeline: unique-cell UVs, Cycles high-to-low normal bake, LOD chain, convex collider, Unity glTF export.</p>
+<p>Hoops evaluate the same <code>host_outer_r</code> chord as the stave flats. <code>--round-band</code> is the falsifier: a circle of <code>radius_at(z)</code> instead of the chord, which is what made the old capped cylinder float off every face. Heads follow the inner stave polygon, not a circle, so they fill the croze instead of leaving triangular slots at every joint.</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 | 4200–4450 | 4312 / 4312 / 4312 | | 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, ≥16 metal hoop faces | 2 slots, 88 hoop faces | | UVs | in <code>0..1</code>, AABB overlap ≤ 1e-5 | in range, overlap 0 | | Outer AABB | (0.719, 0.719, 0.880) m ± 0.01 | (0.7194, 0.7194, 0.8800), zmin 0 | | Collider tris | ≤ 400 | 372 | | Export | written, size &gt; 0 | 327564 / 327564 / 327556 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 | 6000–8500 | 7216 / 7216 / 7216 | | 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; ≥400 wood, ≥200 metal faces | 2 slots; 2512 / 1440 | | UVs | in <code>0..1</code>, AABB overlap ≤ 1e-5 | in range, overlap 0 | | Outer AABB | (0.722, 0.714, 0.880) m ± 0.015 | (0.7220, 0.7142, 0.8800), zmin 0 | | Collider tris | ≤ 400 | 238 | | Export | written, size &gt; 0 | 544140 / 544140 / 544124 bytes |</p>
+<p>Base triangles rose from <strong>4312 to 7216</strong> in the quality pass: 12 identical staves with 5 mm daylight and circular hoops became 20 jittered staves, 8-ring bulge, chord-seated hoops, polygonal croze heads, and a bung.</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. Stave-width jitter uses fixed seed 17. Export byte counts differ by 16 B on 5.2.1 (glTF serializer), not a gated axis.</p>
+<h3>Hygiene</h3>
+<p>Recomputed from the generated mesh, not asserted about the script.</p>
+<p>| Axis | Declared | Measured (all three) | | --- | --- | --- | | Non-manifold edges | 0 | 0 | | Loose verts / edges | 0 / 0 | 0 / 0 | | Doubles merged at 1e-5 | 0 | 0 | | Zero-area faces | 0 | 0 | | N-gons | 0 | 0 | | Coplanar disjoint face pairs | 0 | 0 | | Grounded: <code>zmin</code> | within 1e-4 of 0 | 0.0000 | | Named supports: 20 staves | each <code>zmin</code> ≤ 0.001 | 20, stave_z 0.00000 | | Body plan | 0.714 m dia × 0.880 m high ± 0.04 | 0.7142 × 0.8800 |</p>
+<h3>Joint fit and seat</h3>
+<p>| Axis | Declared | Measured (all three) | | --- | --- | --- | | Head-croze rim BVH gap | ≤ 0.010 m | 0.00698 | | Hoop bite (host r − inner hoop r) | 0.0012–0.008 m | 0.00300 |</p>
+<h3>Falsifiers</h3>
+<p>Each violates one named budget. All six 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-staves</code> | named stave supports at Z=0 | 16 | | <code>--float-head</code> | head-croze gap | 17 | | <code>--round-band</code> | hoop bite band | 18 |</p>
 <h2>Run</h2>
 <pre><code>blender --background --python wooden_barrel.py --
 blender --background --python wooden_barrel.py -- --skip-decimate
+blender --background --python wooden_barrel.py -- --stray-vert
+blender --background --python wooden_barrel.py -- --lift-z
+blender --background --python wooden_barrel.py -- --short-staves
+blender --background --python wooden_barrel.py -- --float-head
+blender --background --python wooden_barrel.py -- --round-band
 blender --background --python wooden_barrel.py -- --output barrel.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 hoop 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 stave floats | | 17 | Joint fit: head-croze gap (<code>--float-head</code>) | | 18 | Seat: hoop bite band (<code>--round-band</code>) | | 19 | Body diameter or height off the stated real-world size |</p>
     </section>
     <section class="detail-section src">
       <h2>Source</h2>
@@ -284,15 +298,23 @@ <h2>Source</h2>
       </div>
       <pre><span class="s">&quot;&quot;&quot;Game-ready wooden barrel — a showcase piece, not an example.
 
-Asserts budget conformance of a procedural staved barrel after composing
-shipped pipeline pieces: bmesh construction, UVs, two materials, high-to-low
-normal bake, LOD chain, convex collider, Unity glTF export.
+Asserts budget conformance of a procedural staved barrel (tight staves
+with seeded width jitter, heads seated in a croze, iron hoops lofted on
+the stave faces, a bung) after composing shipped pipeline pieces: bmesh
+construction, UVs, two materials, high-to-low normal bake, LOD chain,
+convex collider, Unity glTF export.
+
+The old piece was a 12-gon with 5 mm daylight between identical staves
+and circular capped-cylinder hoops that floated off every stave face.
 
 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-staves`` named stave
+supports, ``--float-head`` head-croze joint-fit, ``--round-band`` hoop
+seat (hoop generated on a circle instead of the stave chords).
 
-No RNG. Construction is closed-form. DECIMATE COLLAPSE triangle counts
+Fixed seed 17 for stave-width jitter. DECIMATE COLLAPSE triangle counts
 are not byte-identical across Blender versions — the LOD gate is a
 ratio band, not an exact count.
 
@@ -303,17 +325,16 @@ <h2>Source</h2>
 <span class="k">import</span> argparse
 <span class="k">import</span> math
 <span class="k">import</span> os
+<span class="k">import</span> random
 <span class="k">import</span> sys
 <span class="k">import</span> tempfile
 <span class="k">import</span> traceback
 
 <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,22 +342,46 @@ <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"># Wine-cask scale: 88 cm tall, 72 cm at the bulge.</span>
 HEIGHT = <span class="n">0.88</span>
 R_END = <span class="n">0.27</span>
 R_MID = <span class="n">0.36</span>
-N_STAVES = <span class="n">12</span>
-STAVE_THICK = <span class="n">0.030</span>
-N_RINGS = <span class="n">5</span>
-STAVE_GAP = <span class="n">0.05</span>
-HOOP_ZS = (<span class="n">0.10</span>, <span class="n">0.28</span>, <span class="n">0.60</span>, <span class="n">0.78</span>)
-HOOP_H = <span class="n">0.042</span>
-HOOP_PAD = <span class="n">0.014</span>
-LID_T = <span class="n">0.030</span>
-BBOX_TOL = <span class="n">0.01</span>
-OUTER_SIZE = (<span class="n">0.719</span>, <span class="n">0.719</span>, <span class="n">0.880</span>)
-
-BASE_TRIS_MIN = <span class="n">4200</span>
-BASE_TRIS_MAX = <span class="n">4450</span>
+N_STAVES = <span class="n">20</span>
+STAVE_THICK = <span class="n">0.028</span>
+N_RINGS = <span class="n">8</span>
+STAVE_SEED = <span class="n">17</span>
+STAVE_JITTER = <span class="n">0.08</span>
+GAP_M = <span class="n">0.0012</span>
+HOOP_ZS = (<span class="n">0.085</span>, <span class="n">0.255</span>, <span class="n">0.625</span>, <span class="n">0.795</span>)
+HOOP_H = <span class="n">0.030</span>
+HOOP_PROUD = <span class="n">0.007</span>
+HOOP_BITE = <span class="n">0.003</span>
+HOOP_CHAMFER = <span class="n">0.003</span>
+HOOP_BITE_MIN = <span class="n">0.0012</span>
+HOOP_BITE_MAX = <span class="n">0.008</span>
+LID_T = <span class="n">0.028</span>
+CHIME = <span class="n">0.014</span>
+CROZE_BITE = <span class="n">0.003</span>
+HEAD_GAP_MAX = <span class="n">0.010</span>
+BUNG_Z = <span class="n">0.44</span>
+BUNG_R = <span class="n">0.022</span>
+BUNG_SEGS = <span class="n">24</span>
+STAVE_ZMIN_MAX = <span class="n">0.001</span>
+SHORT_STAVES_LIFT = <span class="n">0.045</span>
+LIFT_Z = <span class="n">0.05</span>
+AREA_EPS = <span class="n">1e-10</span>
+DOUBLES_EPS = <span class="n">1e-5</span>
+ZMIN_EPS = <span class="n">1e-4</span>
+ZFIGHT_EPS = <span class="n">1e-4</span>
+ZFIGHT_COS = <span class="n">0.998</span>
+BODY_TOL = <span class="n">0.04</span>
+BODY_DIA = <span class="n">0.714</span>
+BODY_H = <span class="n">0.880</span>
+BBOX_TOL = <span class="n">0.015</span>
+OUTER_SIZE = (<span class="n">0.722</span>, <span class="n">0.714</span>, <span class="n">0.880</span>)
+
+BASE_TRIS_MIN = <span class="n">6000</span>
+BASE_TRIS_MAX = <span class="n">8500</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>
@@ -344,11 +389,14 @@ <h2>Source</h2>
 LOD1_TARGET = <span class="n">0.50</span>
 LOD2_TARGET = <span class="n">0.22</span>
 MATERIAL_COUNT = <span class="n">2</span>
+WOOD_FACES_MIN = <span class="n">400</span>
+METAL_FACES_MIN = <span class="n">200</span>
 UV_EPS = <span class="n">1e-4</span>
 UV_OVERLAP_MAX = <span class="n">1e-5</span>
 COLLIDER_TRIS_MAX = <span class="n">400</span>
 BAKE_RES = <span class="n">256</span>
 CAGE_EXTRUSION = <span class="n">0.05</span>
+STAVE_COUNT = N_STAVES
 
 WOOD_IDX = <span class="n">0</span>
 METAL_IDX = <span class="n">1</span>
@@ -369,7 +417,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()
@@ -384,30 +431,228 @@ <h2>Source</h2>
     <span class="k">return</span> R_END + (R_MID - R_END) * math.sin(math.pi * z / HEIGHT)
 
 
-<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>)):
+<span class="k">def</span> stave_spans(n, gap_ang, jitter, seed):
+    rng = random.Random(seed)
+    weights = [<span class="n">1.0</span> + rng.uniform(-jitter, jitter) <span class="k">for</span> _ <span class="k">in</span> range(n)]
+    total = sum(weights)
+    usable = <span class="n">2.0</span> * math.pi - n * gap_ang
+    spans = []
+    a = <span class="n">0.0</span>
+    <span class="k">for</span> w <span class="k">in</span> weights:
+        width = usable * (w / total)
+        spans.append((a, a + width))
+        a += width + gap_ang
+    <span class="k">return</span> spans
+
+
+<span class="k">def</span> host_outer_r(u, z, spans, round_band):
+    <span class="s">&quot;&quot;&quot;Radial distance of the outer stave face at angle u.
+
+    One function owns the surface. The hoop, the head croze and the
+    assertions all evaluate it. ``round_band`` is the falsifier: a circle
+    of ``radius_at(z)`` instead of the stave chord, which is what made
+    the old cylinder float off every flat.
+    &quot;&quot;&quot;</span>
+    r = radius_at(z)
+    <span class="k">if</span> round_band:
+        <span class="k">return</span> r
+    u = u % (<span class="n">2.0</span> * math.pi)
+    <span class="k">for</span> a0, a1 <span class="k">in</span> spans:
+        <span class="k">if</span> a0 - <span class="n">1e-9</span> &lt;= u &lt;= a1 + <span class="n">1e-9</span>:
+            mid = <span class="n">0.5</span> * (a0 + a1)
+            half = <span class="n">0.5</span> * (a1 - a0)
+            den = math.cos(u - mid)
+            <span class="k">if</span> abs(den) &lt; <span class="n">1e-4</span>:
+                <span class="k">return</span> r * math.cos(half)
+            <span class="k">return</span> r * math.cos(half) / den
+    <span class="k">return</span> r
+
+
+<span class="k">def</span> loft_cyclic(bm, sections, mat_idx):
+    vert_rings = [[bm.verts.new(p) <span class="k">for</span> p <span class="k">in</span> s] <span class="k">for</span> s <span class="k">in</span> sections]
+    m = len(vert_rings)
+    n = len(vert_rings[<span class="n">0</span>])
+    faces = []
+    <span class="k">for</span> k <span class="k">in</span> range(m):
+        a = vert_rings[k]
+        b = vert_rings[(k + <span class="n">1</span>) % m]
+        <span class="k">for</span> i <span class="k">in</span> range(n):
+            j = (i + <span class="n">1</span>) % n
+            face = bm.faces.new((a[i], a[j], b[j], b[i]))
+            face.material_index = mat_idx
+            faces.append(face)
+    <span class="k">return</span> [v <span class="k">for</span> ring <span class="k">in</span> vert_rings <span class="k">for</span> v <span class="k">in</span> ring], faces
+
+
+<span class="k">def</span> fan_cap(bm, ring, mat_idx, flip=<span class="k">False</span>):
+    center = Vector((<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>))
+    <span class="k">for</span> v <span class="k">in</span> ring:
+        center += v.co
+    center /= len(ring)
+    hub = bm.verts.new(center)
+    faces = []
+    n = len(ring)
+    <span class="k">for</span> i <span class="k">in</span> range(n):
+        vs = (hub, ring[i], ring[(i + <span class="n">1</span>) % n])
+        <span class="k">if</span> flip:
+            vs = (hub, vs[<span class="n">2</span>], vs[<span class="n">1</span>])
+        face = bm.faces.new(vs)
+        face.material_index = mat_idx
+        faces.append(face)
+    <span class="k">return</span> hub, faces
+
+
+<span class="k">def</span> croze_xy(spans, z, bite, shrink=<span class="n">0.0</span>):
+    <span class="s">&quot;&quot;&quot;Head outline = inner stave chords plus croze bite.
+
+    A circle leaves a triangular slot at every stave joint. Sampling
+    each stave at both edges and the mid-face, then connecting in
+    order, makes the head follow the same host as the hoops.
+    &quot;&quot;&quot;</span>
+    pts = []
+    <span class="k">for</span> a0, a1 <span class="k">in</span> spans:
+        <span class="k">for</span> u <span class="k">in</span> (a0, <span class="n">0.5</span> * (a0 + a1), a1):
+            r = host_outer_r(u, z, spans, <span class="k">False</span>) - STAVE_THICK + bite - shrink
+            pts.append((r * math.cos(u), r * math.sin(u)))
+    <span class="k">return</span> pts
+
+
+<span class="k">def</span> add_polygon_disk(bm, z0, z1, xy_ring, mat_idx):
+    rings = []
+    <span class="k">for</span> z <span class="k">in</span> (z0, z1):
+        ring = [bm.verts.new((x, y, z)) <span class="k">for</span> x, y <span class="k">in</span> xy_ring]
+        rings.append(ring)
+    a, b = rings
+    n = len(xy_ring)
+    <span class="k">for</span> i <span class="k">in</span> range(n):
+        j = (i + <span class="n">1</span>) % n
+        face = bm.faces.new((a[i], a[j], b[j], b[i]))
+        face.material_index = mat_idx
+    fan_cap(bm, a, mat_idx, flip=<span class="k">True</span>)
+    fan_cap(bm, b, mat_idx, flip=<span class="k">False</span>)
+
+
+<span class="k">def</span> add_bung(bm, u, z, spans):
+    r_out = host_outer_r(u, z, spans, <span class="k">False</span>)
+    cu, su = math.cos(u), math.sin(u)
+    radial = Vector((cu, su, <span class="n">0.0</span>))
+    origin = radial * (r_out - STAVE_THICK * <span class="n">0.45</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,
+        cap_tris=<span class="k">True</span>,
+        segments=BUNG_SEGS,
+        radius1=BUNG_R,
+        radius2=BUNG_R * <span class="n">0.92</span>,
+        depth=STAVE_THICK + <span class="n">0.018</span>,
     )
     verts = list(geo[<span class="s">&quot;verts&quot;</span>])
-    rot = Euler(euler).to_matrix()
-    origin = Vector(loc)
+    quat = Vector((<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">1.0</span>)).rotation_difference(radial)
+    rot = quat.to_matrix()
     <span class="k">for</span> v <span class="k">in</span> verts:
-        v.co = rot @ v.co + origin
-    bm.faces.ensure_lookup_table()
+        v.co = rot @ v.co + origin + Vector((<span class="n">0.0</span>, <span class="n">0.0</span>, z))
     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
+        f.material_index = WOOD_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> build_hoops(bm, spans, round_band):
+    faces_all = []
+    <span class="k">for</span> z_mid <span class="k">in</span> HOOP_ZS:
+        z0 = z_mid - HOOP_H * <span class="n">0.5</span>
+        z1 = z_mid + HOOP_H * <span class="n">0.5</span>
+        c = HOOP_CHAMFER
+        sections = []
+        samples = []
+        <span class="k">for</span> a0, a1 <span class="k">in</span> spans:
+            samples.append(a0)
+            samples.append(<span class="n">0.5</span> * (a0 + a1))
+            samples.append(a1)
+        <span class="k">for</span> u <span class="k">in</span> samples:
+            cu, su = math.cos(u), math.sin(u)
+            r0 = host_outer_r(u, z0, spans, round_band)
+            r1 = host_outer_r(u, z1, spans, round_band)
+            profile = (
+                (r0 - HOOP_BITE, z0),
+                (r0 + HOOP_PROUD - c, z0),
+                (r0 + HOOP_PROUD, z0 + c),
+                (r1 + HOOP_PROUD, z1 - c),
+                (r1 + HOOP_PROUD - c, z1),
+                (r1 - HOOP_BITE, z1),
+            )
+            sections.append([Vector((r * cu, r * su, z)) <span class="k">for</span> r, z <span class="k">in</span> profile])
+        _verts, faces = loft_cyclic(bm, sections, METAL_IDX)
+        faces_all.extend(faces)
+    <span class="k">return</span> faces_all
+
+
+<span class="k">def</span> build_staves(bm, spans, z0, bevel_offset, bevel_segments):
+    zs = [HEIGHT * i / (N_RINGS - <span class="n">1</span>) <span class="k">for</span> i <span class="k">in</span> range(N_RINGS)]
+    stave_verts = []
+    <span class="k">for</span> a0, a1 <span class="k">in</span> spans:
+        outer = []
+        inner = []
+        <span class="k">for</span> z <span class="k">in</span> zs:
+            r = radius_at(z)
+            ov = (
+                bm.verts.new((r * math.cos(a0), r * math.sin(a0), z0 + z)),
+                bm.verts.new((r * math.cos(a1), r * math.sin(a1), z0 + z)),
+            )
+            ri = r - STAVE_THICK
+            iv = (
+                bm.verts.new((ri * math.cos(a0), ri * math.sin(a0), z0 + z)),
+                bm.verts.new((ri * math.cos(a1), ri * math.sin(a1), z0 + z)),
+            )
+            outer.append(ov)
+            inner.append(iv)
+            stave_verts.extend(ov)
+            stave_verts.extend(iv)
+        <span class="k">for</span> k <span class="k">in</span> range(N_RINGS - <span class="n">1</span>):
+            o0a, o0b = outer[k]
+            o1a, o1b = outer[k + <span class="n">1</span>]
+            i0a, i0b = inner[k]
+            i1a, i1b = inner[k + <span class="n">1</span>]
+            <span class="k">for</span> vs <span class="k">in</span> (
+                (o0a, o1a, o1b, o0b),
+                (i0b, i1b, i1a, i0a),
+                (o0a, i0a, i1a, o1a),
+                (o0b, o1b, i1b, i0b),
+            ):
+                face = bm.faces.new(vs)
+                face.material_index = WOOD_IDX
+        top = bm.faces.new((outer[-<span class="n">1</span>][<span class="n">0</span>], outer[-<span class="n">1</span>][<span class="n">1</span>], inner[-<span class="n">1</span>][<span class="n">1</span>], inner[-<span class="n">1</span>][<span class="n">0</span>]))
+        top.material_index = WOOD_IDX
+        bot = bm.faces.new((outer[<span class="n">0</span>][<span class="n">1</span>], outer[<span class="n">0</span>][<span class="n">0</span>], inner[<span class="n">0</span>][<span class="n">0</span>], inner[<span class="n">0</span>][<span class="n">1</span>]))
+        bot.material_index = WOOD_IDX
+    <span class="k">if</span> bevel_offset &gt; <span class="n">0.0</span>:
+        long_edges = []
+        seen = set()
+        <span class="k">for</span> v <span class="k">in</span> stave_verts:
+            <span class="k">for</span> e <span class="k">in</span> v.link_edges:
+                <span class="k">if</span> e <span class="k">in</span> seen:
+                    <span class="k">continue</span>
+                seen.add(e)
+                a, b = e.verts
+                <span class="k">if</span> abs(a.co.z - b.co.z) &gt; <span class="n">0.02</span>:
+                    long_edges.append(e)
+        <span class="k">if</span> long_edges:
+            bmesh.ops.bevel(
+                bm,
+                geom=long_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>,
+            )
+    <span class="k">return</span> stave_verts
+
+
+<span class="k">def</span> triangulate_ngons(bm):
+    faces = [f <span class="k">for</span> f <span class="k">in</span> bm.faces <span class="k">if</span> len(f.verts) &gt; <span class="n">4</span>]
+    <span class="k">if</span> faces:
+        bmesh.ops.triangulate(bm, faces=faces)
 
 
 <span class="k">def</span> pack_uvs(bm, margin=<span class="n">0.08</span>):
@@ -426,9 +671,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
@@ -453,78 +696,38 @@ <h2>Source</h2>
             )
 
 
-<span class="k">def</span> build_barrel_mesh(name, bevel_offset, bevel_segments):
+<span class="k">def</span> build_barrel_mesh(
+    name,
+    bevel_offset,
+    bevel_segments,
+    short_staves=<span class="k">False</span>,
+    float_head=<span class="k">False</span>,
+    round_band=<span class="k">False</span>,
+):
     bm = bmesh.new()
-    stave_verts = []
+    gap_ang = GAP_M / R_MID
+    spans = stave_spans(N_STAVES, gap_ang, STAVE_JITTER, STAVE_SEED)
+    z0 = SHORT_STAVES_LIFT <span class="k">if</span> short_staves <span class="k">else</span> <span class="n">0.0</span>
     <span class="k">try</span>:
-        zs = [HEIGHT * i / (N_RINGS - <span class="n">1</span>) <span class="k">for</span> i <span class="k">in</span> range(N_RINGS)]
-        <span class="k">for</span> i <span class="k">in</span> range(N_STAVES):
-            a0 = <span class="n">2.0</span> * math.pi * i / N_STAVES
-            a1 = <span class="n">2.0</span> * math.pi * (i + <span class="n">1.0</span> - STAVE_GAP) / N_STAVES
-            outer = []
-            inner = []
-            <span class="k">for</span> z <span class="k">in</span> zs:
-                r = radius_at(z)
-                ov = (
-                    bm.verts.new((r * math.cos(a0), r * math.sin(a0), z)),
-                    bm.verts.new((r * math.cos(a1), r * math.sin(a1), z)),
-                )
-                ri = r - STAVE_THICK
-                iv = (
-                    bm.verts.new((ri * math.cos(a0), ri * math.sin(a0), z)),
-                    bm.verts.new((ri * math.cos(a1), ri * math.sin(a1), z)),
-                )
-                outer.append(ov)
-                inner.append(iv)
-                stave_verts.extend(ov)
-                stave_verts.extend(iv)
-            <span class="k">for</span> k <span class="k">in</span> range(N_RINGS - <span class="n">1</span>):
-                o0a, o0b = outer[k]
-                o1a, o1b = outer[k + <span class="n">1</span>]
-                i0a, i0b = inner[k]
-                i1a, i1b = inner[k + <span class="n">1</span>]
-                <span class="k">for</span> vs <span class="k">in</span> (
-                    (o0a, o1a, o1b, o0b),
-                    (i0b, i1b, i1a, i0a),
-                    (o0a, i0a, i1a, o1a),
-                    (o0b, o1b, i1b, i0b),
-                ):
-                    face = bm.faces.new(vs)
-                    face.material_index = WOOD_IDX
-            top = bm.faces.new((outer[-<span class="n">1</span>][<span class="n">0</span>], outer[-<span class="n">1</span>][<span class="n">1</span>], inner[-<span class="n">1</span>][<span class="n">1</span>], inner[-<span class="n">1</span>][<span class="n">0</span>]))
-            top.material_index = WOOD_IDX
-            bot = bm.faces.new((outer[<span class="n">0</span>][<span class="n">1</span>], outer[<span class="n">0</span>][<span class="n">0</span>], inner[<span class="n">0</span>][<span class="n">0</span>], inner[<span class="n">0</span>][<span class="n">1</span>]))
-            bot.material_index = 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> stave_verts <span class="k">for</span> e <span class="k">in</span> v.link_edges})
-            bmesh.ops.bevel(
-                bm,
-                geom=edges,
-                offset=bevel_offset,
-                segments=bevel_segments,
-                profile=<span class="n">0.5</span>,
-                affect=<span class="s">&quot;EDGES&quot;</span>,
-                clamp_overlap=<span class="k">True</span>,
-            )
-
-        add_cylinder(bm, (<span class="n">0.0</span>, <span class="n">0.0</span>, LID_T / <span class="n">2.0</span>), R_END - <span class="n">0.012</span>, LID_T, <span class="n">16</span>, WOOD_IDX)
-        add_cylinder(
-            bm, (<span class="n">0.0</span>, <span class="n">0.0</span>, HEIGHT - LID_T / <span class="n">2.0</span>), R_END - <span class="n">0.012</span>, LID_T, <span class="n">16</span>, WOOD_IDX,
+        build_staves(bm, spans, z0, bevel_offset, bevel_segments)
+        shrink = <span class="n">0.028</span> <span class="k">if</span> float_head <span class="k">else</span> <span class="n">0.0</span>
+        bot_z0 = CHIME
+        bot_z1 = CHIME + LID_T
+        top_z0 = HEIGHT - CHIME - LID_T
+        top_z1 = HEIGHT - CHIME
+        add_polygon_disk(
+            bm, bot_z0, bot_z1,
+            croze_xy(spans, <span class="n">0.5</span> * (bot_z0 + bot_z1), CROZE_BITE, shrink),
+            WOOD_IDX,
         )
-        hoop_faces = set()
-        <span class="k">for</span> z <span class="k">in</span> HOOP_ZS:
-            before = set(bm.faces)
-            add_cylinder(
-                bm,
-                (<span class="n">0.0</span>, <span class="n">0.0</span>, z),
-                radius_at(z) + HOOP_PAD,
-                HOOP_H,
-                <span class="n">20</span>,
-                METAL_IDX,
-            )
-            hoop_faces.update(set(bm.faces) - before)
-
+        add_polygon_disk(
+            bm, top_z0, top_z1,
+            croze_xy(spans, <span class="n">0.5</span> * (top_z0 + top_z1), CROZE_BITE, shrink),
+            WOOD_IDX,
+        )
+        add_bung(bm, <span class="n">0.5</span> * (spans[<span class="n">0</span>][<span class="n">0</span>] + spans[<span class="n">0</span>][<span class="n">1</span>]), BUNG_Z, spans)
+        build_hoops(bm, spans, round_band)
+        triangulate_ngons(bm)
         pack_uvs(bm)
         bmesh.ops.recalc_face_normals(bm, faces=list(bm.faces))
         <span class="k">for</span> face <span class="k">in</span> bm.faces:
@@ -534,9 +737,6 @@ <h2>Source</h2>
             <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>):
                     edge.smooth = <span class="k">False</span>
-        <span class="k">for</span> f <span class="k">in</span> hoop_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()
@@ -547,29 +747,44 @@ <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 hoop faces onto wood.</span>
     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):
@@ -580,6 +795,17 @@ <h2>Source</h2>
     <span class="k">return</span> (min(xs), min(ys), min(zs), max(xs), max(ys), max(zs))
 
 
+<span class="k">def</span> face_area(me, poly):
+    verts = [me.vertices[i].co <span class="k">for</span> i <span class="k">in</span> poly.vertices]
+    <span class="k">if</span> len(verts) &lt; <span class="n">3</span>:
+        <span class="k">return</span> <span class="n">0.0</span>
+    acc = Vector((<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>))
+    origin = verts[<span class="n">0</span>]
+    <span class="k">for</span> a, b <span class="k">in</span> zip(verts[<span class="n">1</span>:], verts[<span class="n">2</span>:]):
+        acc += (a - origin).cross(b - origin)
+    <span class="k">return</span> <span class="n">0.5</span> * acc.length
+
+
 <span class="k">def</span> uv_stats(mesh):
     uv = mesh.uv_layers.active
     <span class="k">if</span> uv <span class="k">is</span> <span class="k">None</span>:
@@ -605,6 +831,204 @@ <h2>Source</h2>
     <span class="k">return</span> min(us), min(vs), max(us), max(vs), overlap, len(aabbs)
 
 
+<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)
+    staves = []
+    <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)
+        dz = a[<span class="n">5</span>] - a[<span class="n">2</span>]
+        <span class="k">if</span> dz &gt; <span class="n">0.50</span>:
+            staves.append(a)
+    stave_z = min((a[<span class="n">2</span>] <span class="k">for</span> a <span class="k">in</span> staves), default=<span class="n">99.0</span>)
+    <span class="k">return</span> {<span class="s">&quot;staves&quot;</span>: len(staves), <span class="s">&quot;stave_z&quot;</span>: stave_z}
+
+
+<span class="k">def</span> hoop_seat(me, spans):
+    groups = shells(me)
+    bites = []
+    <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.08</span> <span class="k">or</span> max(dx, dy) &lt; <span class="n">0.40</span>:
+            <span class="k">continue</span>
+        rs = [math.hypot(me.vertices[i].co.x, me.vertices[i].co.y) <span class="k">for</span> i <span class="k">in</span> g]
+        <span class="k">for</span> i, r <span class="k">in</span> zip(g, rs):
+            p = me.vertices[i].co
+            u = math.atan2(p.y, p.x)
+            host = host_outer_r(u, p.z, spans, <span class="k">False</span>)
+            <span class="k">if</span> r &gt; host + <span class="n">0.0005</span>:
+                <span class="k">continue</span>
+            bites.append(host - r)
+    <span class="k">if</span> <span class="k">not</span> bites:
+        <span class="k">return</span> <span class="n">0.05</span>, <span class="n">0.05</span>
+    <span class="k">return</span> min(bites), max(bites)
+
+
+<span class="k">def</span> head_gap(me, spans):
+    groups = shells(me)
+    heads, staves = [], []
+    <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)
+        dz = a[<span class="n">5</span>] - a[<span class="n">2</span>]
+        r = <span class="n">0.25</span> * ((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> dz &lt; <span class="n">0.06</span> <span class="k">and</span> r &gt; <span class="n">0.15</span>:
+            heads.append(g)
+        <span class="k">elif</span> dz &gt; <span class="n">0.50</span>:
+            staves.append(g)
+    <span class="k">if</span> <span class="k">not</span> heads <span class="k">or</span> <span class="k">not</span> staves:
+        <span class="k">return</span> <span class="n">99.0</span>
+    bm_s = bmesh.new()
+    <span class="k">try</span>:
+        bm_s.from_mesh(me)
+        keep = set()
+        <span class="k">for</span> g <span class="k">in</span> staves:
+            keep.update(g)
+        drop = [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> keep <span class="k">for</span> v <span class="k">in</span> f.verts)]
+        <span class="k">if</span> drop:
+            bmesh.ops.delete(bm_s, geom=drop, context=<span class="s">&quot;FACES&quot;</span>)
+        <span class="k">if</span> <span class="k">not</span> bm_s.faces:
+            <span class="k">return</span> <span class="n">99.0</span>
+        tree = BVHTree.FromBMesh(bm_s)
+        worst = <span class="n">0.0</span>
+        <span class="k">for</span> g <span class="k">in</span> heads:
+            a = shell_aabb(me, g)
+            <span class="k">if</span> a[<span class="n">2</span>] &gt; <span class="n">0.2</span>:
+                <span class="k">continue</span>
+            rmax = max(math.hypot(me.vertices[i].co.x, me.vertices[i].co.y) <span class="k">for</span> i <span class="k">in</span> g)
+            <span class="k">for</span> i <span class="k">in</span> g:
+                p = me.vertices[i].co
+                <span class="k">if</span> math.hypot(p.x, p.y) &lt; <span class="n">0.90</span> * rmax:
+                    <span class="k">continue</span>
+                loc, _n, _i, dist = tree.find_nearest(p)
+                <span class="k">if</span> loc <span class="k">is</span> <span class="k">None</span>:
+                    <span class="k">continue</span>
+                worst = max(worst, dist)
+        <span class="k">return</span> worst
+    <span class="k">finally</span>:
+        bm_s.free()
+
+
+<span class="k">def</span> body_plan(me):
+    groups = shells(me)
+    xs, ys, z0s, z1s = [], [], [], []
+    <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)
+        <span class="k">if</span> a[<span class="n">5</span>] - a[<span class="n">2</span>] &lt; <span class="n">0.50</span>:
+            <span class="k">continue</span>
+        xs.extend((a[<span class="n">0</span>], a[<span class="n">3</span>]))
+        ys.extend((a[<span class="n">1</span>], a[<span class="n">4</span>]))
+        z0s.append(a[<span class="n">2</span>])
+        z1s.append(a[<span class="n">5</span>])
+    <span class="k">if</span> <span class="k">not</span> xs:
+        <span class="k">return</span> <span class="n">0.0</span>, <span class="n">0.0</span>
+    dia = <span class="n">0.5</span> * ((max(xs) - min(xs)) + (max(ys) - min(ys)))
+    <span class="k">return</span> dia, max(z1s) - min(z0s)
+
+
+<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>, HEIGHT * <span class="n">0.5</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)
@@ -618,7 +1042,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>:
@@ -630,6 +1053,14 @@ <h2>Source</h2>
             bmesh.ops.delete(bm, geom=interior, context=<span class="s">&quot;VERTS&quot;</span>)
         <span class="k">if</span> unused:
             bmesh.ops.delete(bm, geom=unused, context=<span class="s">&quot;VERTS&quot;</span>)
+        bmesh.ops.dissolve_limit(
+            bm,
+            angle_limit=math.radians(<span class="n">10.0</span>),
+            verts=list(bm.verts),
+            edges=list(bm.edges),
+            delimit={<span class="s">&quot;NORMAL&quot;</span>},
+        )
+        bmesh.ops.triangulate(bm, faces=list(bm.faces))
         bm.to_mesh(mesh)
         mesh.update()
     <span class="k">finally</span>:
@@ -641,7 +1072,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;BarrelNrm&quot;</span>, size, size, alpha=<span class="k">True</span>, float_buffer=<span class="k">False</span>)
@@ -656,7 +1086,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>
@@ -681,7 +1110,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:
@@ -697,18 +1125,44 @@ <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_staves=<span class="k">False</span>,
+    float_head=<span class="k">False</span>,
+    round_band=<span class="k">False</span>,
+):
     bpy.ops.wm.read_factory_settings(use_empty=<span class="k">True</span>)
-    low = build_barrel_mesh(<span class="s">&quot;BarrelLow&quot;</span>, bevel_offset=<span class="n">0.006</span>, bevel_segments=<span class="n">2</span>)
-    high = build_barrel_mesh(<span class="s">&quot;BarrelHigh&quot;</span>, bevel_offset=<span class="n">0.006</span>, bevel_segments=<span class="n">4</span>)
-    wood = principled(<span class="s">&quot;BarrelWood&quot;</span>, (<span class="n">0.48</span>, <span class="n">0.22</span>, <span class="n">0.07</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.50</span>)
-    metal = principled(<span class="s">&quot;BarrelMetal&quot;</span>, (<span class="n">0.62</span>, <span class="n">0.60</span>, <span class="n">0.56</span>, <span class="n">1.0</span>), <span class="n">1.0</span>, <span class="n">0.22</span>)
+    flags = dict(
+        short_staves=short_staves,
+        float_head=float_head,
+        round_band=round_band,
+    )
+    low = build_barrel_mesh(<span class="s">&quot;BarrelLow&quot;</span>, <span class="n">0.004</span>, <span class="n">2</span>, **flags)
+    high = build_barrel_mesh(<span class="s">&quot;BarrelHigh&quot;</span>, <span class="n">0.004</span>, <span class="n">4</span>, **flags)
+    wood = principled(
+        <span class="s">&quot;BarrelWood&quot;</span>, (<span class="n">0.48</span>, <span class="n">0.22</span>, <span class="n">0.07</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;BarrelHoop&quot;</span>, (<span class="n">0.55</span>, <span class="n">0.53</span>, <span class="n">0.50</span>, <span class="n">1.0</span>), <span class="n">1.0</span>, <span class="n">0.28</span>,
+        noise_scale=<span class="n">5.0</span>, wear=(<span class="n">0.35</span>, <span class="n">0.32</span>, <span class="n">0.28</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;barrel 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>
 
+    spans = stave_spans(N_STAVES, GAP_M / R_MID, STAVE_JITTER, STAVE_SEED)
     base_tris = triangle_count(low.data)
     mats = [s <span class="k">for</span> s <span class="k">in</span> low.data.materials <span class="k">if</span> s <span class="k">is</span> <span class="k">not</span> <span class="k">None</span>]
     nmat = len(mats)
@@ -722,6 +1176,22 @@ <h2>Source</h2>
     size_x = bb[<span class="n">3</span>] - bb[<span class="n">0</span>]
     size_y = bb[<span class="n">4</span>] - bb[<span class="n">1</span>]
     size_z = bb[<span class="n">5</span>] - bb[<span class="n">2</span>]
+    hyg = hygiene_audit(low.data)
+    zf = zfight_pairs(low.data)
+    sup = support_audit(low.data)
+    bite_min, bite_max = hoop_seat(low.data, spans)
+    hgap = head_gap(low.data, spans)
+    dia, ht = body_plan(low.data)
+    print(
+        <span class="s">f&quot;</span><span class="s">measured hygiene loose_v=</span>{hyg[<span class="s">&#x27;loose_v&#x27;</span>]}<span class="s"> loose_e=</span>{hyg[<span class="s">&#x27;loose_e&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">nonman=</span>{hyg[<span class="s">&#x27;nonman&#x27;</span>]}<span class="s"> zero_area=</span>{hyg[<span class="s">&#x27;zero_area&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">doubles=</span>{hyg[<span class="s">&#x27;doubles&#x27;</span>]}<span class="s"> ngons=</span>{hyg[<span class="s">&#x27;ngons&#x27;</span>]}<span class="s"> zfight=</span>{zf}<span class="s">&quot;</span>
+    )
+    print(
+        <span class="s">f&quot;</span><span class="s">measured staves=</span>{sup[<span class="s">&#x27;staves&#x27;</span>]}<span class="s"> stave_z=</span>{sup[<span class="s">&#x27;stave_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">hoop_bite=</span>{bite_min:<span class="s">.5f</span>}<span class="s">..</span>{bite_max:<span class="s">.5f</span>}<span class="s"> head_gap=</span>{hgap:<span class="s">.5f</span>}<span class="s"> </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">body=</span>{dia:<span class="s">.4f</span>}<span class="s">x</span>{ht:<span class="s">.4f</span>}<span class="s">&quot;</span>
+    )
 
     img, tex = setup_bake_image(low, wood)
     <span class="k">if</span> img <span class="k">is</span> <span class="k">None</span>:
@@ -736,7 +1206,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_barrel_mesh(<span class="s">&quot;BarrelColSrc&quot;</span>, bevel_offset=<span class="n">0.0</span>, bevel_segments=<span class="n">1</span>)
+    collider_src = build_barrel_mesh(<span class="s">&quot;BarrelColSrc&quot;</span>, <span class="n">0.0</span>, <span class="n">1</span>)
     collider = convex_hull_collider(collider_src, <span class="s">&quot;BarrelCollider&quot;</span>)
     bpy.data.objects.remove(collider_src, do_unlink=<span class="k">True</span>)
     col_tris = triangle_count(collider.data)
@@ -750,9 +1220,7 @@ <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>
-    )
+    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>
@@ -780,9 +1248,14 @@ <h2>Source</h2>
             <span class="s">f&quot;</span><span class="s">material slots </span>{nmat}<span class="s"> distinct </span>{distinct_mats}<span class="s"> != </span>{MATERIAL_COUNT}<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(METAL_IDX, <span class="n">0</span>) &lt; <span class="n">16</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> idx_counts.get(METAL_IDX, <span class="n">0</span>) &lt; METAL_FACES_MIN:
         <span class="k">return</span> fail(
-            <span class="s">f&quot;</span><span class="s">metal hoop faces </span>{idx_counts.get(METAL_IDX, <span class="n">0</span>)}<span class="s"> &lt; 16</span><span class="s">&quot;</span>,
+            <span class="s">f&quot;</span><span class="s">metal hoop 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> 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:
@@ -795,6 +1268,32 @@ <h2>Source</h2>
             <span class="s">f&quot;</span><span class="s">UV AABB overlap </span>{overlap:<span class="s">.6f</span>}<span class="s"> &gt; </span>{UV_OVERLAP_MAX}<span class="s">&quot;</span>,
             <span class="n">7</span>,
         ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+    <span class="k">if</span> (
+        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"> </span><span class="s">&quot;</span>
+            <span class="s">&quot;(--stray-vert is the designed fail)&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">or</span> sup[<span class="s">&quot;staves&quot;</span>] != STAVE_COUNT
+        <span class="k">or</span> sup[<span class="s">&quot;stave_z&quot;</span>] &gt; STAVE_ZMIN_MAX
+    ):
+        <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"> staves=</span>{sup[<span class="s">&#x27;staves&#x27;</span>]}<span class="s"> stave_z=</span>{sup[<span class="s">&#x27;stave_z&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">&quot;(--lift-z / --short-staves is the designed fail)&quot;</span>,
+            <span class="n">16</span>,
+        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
     <span class="k">if</span> (
         abs(size_x - OUTER_SIZE[<span class="n">0</span>]) &gt; BBOX_TOL
         <span class="k">or</span> abs(size_y - OUTER_SIZE[<span class="n">1</span>]) &gt; BBOX_TOL
@@ -828,6 +1327,24 @@ <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> hgap &gt; HEAD_GAP_MAX:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">head-croze gap </span>{hgap:<span class="s">.5f</span>}<span class="s"> &gt; </span>{HEAD_GAP_MAX}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">&quot;(--float-head 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> bite_min &lt; HOOP_BITE_MIN <span class="k">or</span> bite_max &gt; HOOP_BITE_MAX:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">hoop bite </span>{bite_min:<span class="s">.5f</span>}<span class="s">..</span>{bite_max:<span class="s">.5f</span>}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">f&quot;</span><span class="s">outside [</span>{HOOP_BITE_MIN}<span class="s">, </span>{HOOP_BITE_MAX}<span class="s">] </span><span class="s">&quot;</span>
+            <span class="s">&quot;(--round-band 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(dia - BODY_DIA) &gt; BODY_TOL <span class="k">or</span> abs(ht - BODY_H) &gt; BODY_TOL:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">body plan </span>{dia:<span class="s">.4f</span>}<span class="s">x</span>{ht:<span class="s">.4f</span>}<span class="s"> off </span>{BODY_DIA}<span class="s">x</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
 
 
@@ -840,9 +1357,8 @@ <h2>Source</h2>
     nt.links.new(nrm.outputs[<span class="s">&quot;Normal&quot;</span>], bsdf.inputs[<span class="s">&quot;Normal&quot;</span>])
 
 
-<span class="k">def</span> render_still(low, wood, tex, path, engine):
+<span class="k">def</span> render_still(low, wood, _tex, path, engine):
     scene = bpy.context.scene
-    wire_normal(wood, tex)
     <span class="k">for</span> ob <span class="k">in</span> list(scene.objects):
         <span class="k">if</span> ob.type == <span class="s">&quot;MESH&quot;</span> <span class="k">and</span> ob != low:
             ob.hide_render = <span class="k">True</span>
@@ -941,14 +1457,22 @@ <h2>Source</h2>
     p = argparse.ArgumentParser()
     p.add_argument(<span class="s">&quot;--output&quot;</span>, default=<span class="k">None</span>)
     p.add_argument(<span class="s">&quot;--engine&quot;</span>, default=<span class="s">&quot;eevee&quot;</span>, choices=(<span class="s">&quot;eevee&quot;</span>, <span class="s">&quot;cycles&quot;</span>))
-    p.add_argument(
-        <span class="s">&quot;--skip-decimate&quot;</span>,
-        action=<span class="s">&quot;store_true&quot;</span>,
-        help=<span class="s">&quot;falsification: skip the LOD DECIMATE stage&quot;</span>,
-    )
+    p.add_argument(<span class="s">&quot;--skip-decimate&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--stray-vert&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--lift-z&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--short-staves&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--float-head&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--round-band&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_staves=args.short_staves,
+        float_head=args.float_head,
+        round_band=args.round_band,
+    )
     <span class="k">if</span> code:
         <span class="k">return</span> code
     <span class="k">if</span> args.output:
diff --git a/docs/gallery/wooden-bucket/index.html b/docs/gallery/wooden-bucket/index.html
index e493fce..35dfb78 100644
--- a/docs/gallery/wooden-bucket/index.html
+++ b/docs/gallery/wooden-bucket/index.html
@@ -4,18 +4,18 @@
   <meta charset="utf-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1" />
   <title>wooden-bucket — Examples — Blender Developer Tools</title>
-  <meta name="description" content="A procedural coopered wooden bucket with overlapping staves, a sealed bottom, iron hoops, and a rope bail through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
+  <meta name="description" content="A procedural coopered pail with a croze-seated floor, chord-lofted hoops, and a round bail through the ear rings through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
   <link rel="canonical" href="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/wooden-bucket/" />
   <link rel="icon" href="../../assets/favicon.svg" type="image/svg+xml" />
   <meta name="theme-color" content="#1a1b1e" />
   <meta property="og:type" content="website" />
   <meta property="og:title" content="wooden-bucket — Examples — Blender Developer Tools" />
-  <meta property="og:description" content="A procedural coopered wooden bucket with overlapping staves, a sealed bottom, iron hoops, and a rope bail through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
+  <meta property="og:description" content="A procedural coopered pail with a croze-seated floor, chord-lofted hoops, and a round bail through the ear rings through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
   <meta property="og:url" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/wooden-bucket/" />
   <meta property="og:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/wooden-bucket-hero.webp" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="wooden-bucket — Examples — Blender Developer Tools" />
-  <meta name="twitter:description" content="A procedural coopered wooden bucket with overlapping staves, a sealed bottom, iron hoops, and a rope bail through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
+  <meta name="twitter:description" content="A procedural coopered pail with a croze-seated floor, chord-lofted hoops, and a round bail through the ear rings through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
   <meta name="twitter:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/wooden-bucket-hero.webp" />
   <style>
     /* fonts are deployed by the landing build (docs/fonts/) */
@@ -246,35 +246,50 @@
   </div>
   <header class="hero">
     <h1>wooden-bucket</h1>
-    <p>A procedural coopered wooden bucket with overlapping staves, a sealed bottom, iron hoops, and a rope bail through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.</p>
+    <p>A procedural coopered pail with a croze-seated floor, chord-lofted hoops, and a round bail through the ear rings through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.</p>
   </header>
   <main id="main">
     <button class="detail-hero" id="heroZoom" type="button" aria-label="Zoom wooden-bucket render">
       <img src="../assets/wooden-bucket-hero.webp" alt="wooden-bucket 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: 4272 tris, three materials with 222 metal and 72 rope faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.402×0.345×0.544 m, LOD ratios in band, convex collider 390 tris, non-empty glTF. --skip-decimate exits 9 on the LOD1 ratio budget.</div>
+    <div class="callout"><span class="tag">witnesses</span> Recomputed: 4872 tris, three materials with 1424 wood, 1020 metal, and 208 rope faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.383×0.346×0.527 m, 16 grounded staves, hoop bite 0.0025 m, bail-ear gap 0.0013 m, LOD ratios in band, convex collider 302 tris, non-empty glTF. --skip-decimate exits 9; --float-handle exits 17 on the bail-ear budget.</div>
     <div class="runline">
       <pre id="runCmd">blender --background --python showcase/wooden-bucket/wooden_bucket.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 coopered bucket (overlapping staves, sealed bottom, iron hoops, ears, rope bail) 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 coopered pail (16 staves with seeded width jitter, a bottom seated in a croze above a chime, iron hoops lofted on the stave faces, ear plates and rings, a round rope bail through the rings) then the shipped pipeline: unique-cell UVs, Cycles high-to-low normal bake, LOD chain, convex collider, Unity glTF export.</p>
+<p>Hoops evaluate the same <code>host_outer_r</code> chord as the stave flats. <code>--round-band</code> is the falsifier: a circle of <code>radius_at(z)</code> instead of the chord. The floor follows the inner stave polygon. Ear plates sit on the outer stave face below the rim; the bail is a semicircle whose ends pass through the rings. <code>--float-handle</code> shrinks that semicircle so the bar sits on the ring; <code>--float-bottom</code> shrinks the floor out of the croze.</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 | 4150–4400 | 4272 / 4272 / 4272 | | LOD1 ratio | 0.32–0.62 of base | 0.5000 / 0.5000 / 0.5000 | | LOD2 ratio | 0.10–0.35 of base | 0.2196 / 0.2196 / 0.2196 | | Materials | exactly 3 distinct, ≥24 metal, ≥12 rope | 3 slots, 222 metal, 72 rope | | UVs | in <code>0..1</code>, AABB overlap ≤ 1e-5 | in range, overlap 0 | | Outer AABB | (0.402, 0.345, 0.544) m ± 0.01 | (0.4020, 0.3449, 0.5439), zmin 0 | | Collider tris | ≤ 420 | 390 | | Export | written, size &gt; 0 | 330476 / 330476 / 330464 bytes |</p>
-<p>DECIMATE COLLAPSE triangle counts are <strong>not</strong> identical across series — the gate is a ratio band, not an exact count. Bake pixels are stochastic; the gate is <code>has_data</code> plus operator <code>FINISHED</code>, not byte-identity. Construction uses no RNG. Export byte counts differ by 12 B on 5.2.1 (glTF serializer), not a gated axis.</p>
-<p><code>--skip-decimate</code> skips the LOD DECIMATE stage so LOD1 ratio is 1.0 and exit 9 fires. That is the named budget the falsifier violates.</p>
+<p>| Axis | Declared | Measured (4.5.11 / 5.1.2 / 5.2.1) | | --- | --- | --- | | Base triangles | 4000–5800 | 4872 / 4872 / 4872 | | 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.2188 | | Materials | exactly 3 distinct; ≥350 wood, ≥180 metal, ≥40 rope | 3 slots; 1424 / 1020 / 208 | | UVs | in <code>0..1</code>, AABB overlap ≤ 1e-5 | in range, overlap 0 | | Outer AABB | (0.383, 0.346, 0.527) m ± 0.015 | (0.3832, 0.3462, 0.5271), zmin 0 | | Collider tris | ≤ 420 | 302 | | Export | written, size &gt; 0 | 378296 / 378296 / 378276 bytes |</p>
+<p>Base triangles rose from <strong>4272 to 4872</strong> in the quality pass: overlapping identical staves, circular hoops, and a 12-box bail became 16 jittered staves, chord-seated hoops, a polygonal croze floor, and a round bail through the ear rings.</p>
+<p>DECIMATE COLLAPSE triangle counts are <strong>not</strong> identical across series — 5.2.1 is 4 tris leaner on LOD2. The gate is a ratio band, not an exact count. Bake pixels are stochastic; the gate is <code>has_data</code> plus operator <code>FINISHED</code>, not byte-identity. Stave-width jitter uses fixed seed 17. Export byte counts differ by 20 B on 5.2.1 (glTF serializer), not a gated axis.</p>
+<h3>Hygiene</h3>
+<p>Recomputed from the generated mesh, not asserted about the script.</p>
+<p>| Axis | Declared | Measured (all three) | | --- | --- | --- | | Non-manifold edges | 0 | 0 | | Loose verts / edges | 0 / 0 | 0 / 0 | | Doubles merged at 1e-5 | 0 | 0 | | Zero-area faces | 0 | 0 | | N-gons | 0 | 0 | | Coplanar disjoint face pairs | 0 | 0 | | Grounded: <code>zmin</code> | within 1e-4 of 0 | 0.0000 | | Named supports: 16 staves | each <code>zmin</code> ≤ 0.001 | 16, stave_z 0.00000 | | Body plan | 0.335 m dia × 0.360 m high ± 0.04 | 0.3349 × 0.3600 |</p>
+<h3>Joint fit and seat</h3>
+<p>| Axis | Declared | Measured (all three) | | --- | --- | --- | | Bail-ear BVH gap | ≤ 0.006 m | 0.00125 | | Floor-croze rim BVH gap | ≤ 0.008 m | 0.00458 | | Hoop bite (host r − inner hoop r) | 0.0010–0.007 m | 0.00250 |</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-staves</code> | named stave supports at Z=0 | 16 | | <code>--float-handle</code> | bail-ear gap | 17 | | <code>--float-bottom</code> | floor-croze gap | 17 | | <code>--round-band</code> | hoop bite band | 18 |</p>
 <h2>Run</h2>
 <pre><code>blender --background --python wooden_bucket.py --
 blender --background --python wooden_bucket.py -- --skip-decimate
+blender --background --python wooden_bucket.py -- --stray-vert
+blender --background --python wooden_bucket.py -- --lift-z
+blender --background --python wooden_bucket.py -- --short-staves
+blender --background --python wooden_bucket.py -- --float-handle
+blender --background --python wooden_bucket.py -- --float-bottom
+blender --background --python wooden_bucket.py -- --round-band
 blender --background --python wooden_bucket.py -- --output bucket.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 ≠ 3 distinct slots, or metal/rope 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 ≠ 3 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 stave floats | | 17 | Joint fit: bail-ear gap or floor-croze gap | | 18 | Seat: hoop bite band (<code>--round-band</code>) | | 19 | Body diameter or height off the stated real-world size |</p>
     </section>
     <section class="detail-section src">
       <h2>Source</h2>
@@ -284,15 +299,26 @@ <h2>Source</h2>
       </div>
       <pre><span class="s">&quot;&quot;&quot;Game-ready wooden bucket — a showcase piece, not an example.
 
-Asserts budget conformance of a procedural coopered bucket after composing
-shipped pipeline pieces: bmesh construction, UVs, three materials,
-high-to-low normal bake, LOD chain, convex collider, Unity glTF export.
+Asserts budget conformance of a procedural coopered bucket (tight staves
+with seeded width jitter, a bottom seated in a croze, iron hoops lofted
+on the stave faces, ear rings, a round rope bail through the rings)
+after composing shipped pipeline pieces: bmesh construction, UVs, three
+materials, high-to-low normal bake, LOD chain, convex collider, Unity
+glTF export.
 
-Budgets are declared below and recomputed from the generated result.
-They are not API-contract witnesses. ``--skip-decimate`` skips the LOD
-DECIMATE stage so the LOD-ratio budget fails.
+The old piece overlapped 14 identical staves into a 14-gon, wrapped them
+in capped-cylinder hoops that floated off the flats, and lofted the bail
+from 12 boxes that never entered the ear rings.
 
-No RNG. Construction is closed-form. DECIMATE COLLAPSE triangle counts
+Budgets are declared below and recomputed from the generated result.
+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-staves`` named stave
+supports, ``--float-handle`` bail-ear joint-fit, ``--float-bottom``
+floor-croze joint-fit, ``--round-band`` hoop seat (hoop generated on a
+circle instead of the stave chords).
+
+Fixed seed 17 for stave-width jitter. DECIMATE COLLAPSE triangle counts
 are not byte-identical across Blender versions — the LOD gate is a
 ratio band, not an exact count.
 
@@ -303,6 +329,7 @@ <h2>Source</h2>
 <span class="k">import</span> argparse
 <span class="k">import</span> math
 <span class="k">import</span> os
+<span class="k">import</span> random
 <span class="k">import</span> sys
 <span class="k">import</span> tempfile
 <span class="k">import</span> traceback
@@ -310,10 +337,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,26 +346,51 @@ <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"># Pail scale: 36 cm bowl, 33 cm rim.</span>
 HEIGHT = <span class="n">0.36</span>
 R_BOT = <span class="n">0.125</span>
 R_TOP = <span class="n">0.168</span>
-N_STAVES = <span class="n">14</span>
-STAVE_THICK = <span class="n">0.022</span>
-N_RINGS = <span class="n">4</span>
-<span class="c"># Negative gap = overlapping staves so the hull is sealed.</span>
-STAVE_GAP = -<span class="n">0.08</span>
-HOOP_ZS = (<span class="n">0.055</span>, <span class="n">0.155</span>, <span class="n">0.305</span>)
-HOOP_H = <span class="n">0.026</span>
-HOOP_PAD = <span class="n">0.011</span>
-BOTTOM_T = <span class="n">0.024</span>
-BAIL_R = <span class="n">0.012</span>
-BAIL_SEGS = <span class="n">12</span>
-BBOX_TOL = <span class="n">0.01</span>
-<span class="c"># Fitted after locking geometry. Recomputed from bound_box.</span>
-OUTER_SIZE = (<span class="n">0.402</span>, <span class="n">0.345</span>, <span class="n">0.544</span>)
-
-BASE_TRIS_MIN = <span class="n">4150</span>
-BASE_TRIS_MAX = <span class="n">4400</span>
+BULGE = <span class="n">0.012</span>
+N_STAVES = <span class="n">16</span>
+STAVE_THICK = <span class="n">0.018</span>
+N_RINGS = <span class="n">6</span>
+STAVE_SEED = <span class="n">17</span>
+STAVE_JITTER = <span class="n">0.08</span>
+GAP_M = <span class="n">0.0007</span>
+HOOP_ZS = (<span class="n">0.055</span>, <span class="n">0.155</span>, <span class="n">0.300</span>)
+HOOP_H = <span class="n">0.022</span>
+HOOP_PROUD = <span class="n">0.006</span>
+HOOP_BITE = <span class="n">0.0025</span>
+HOOP_CHAMFER = <span class="n">0.0025</span>
+HOOP_BITE_MIN = <span class="n">0.0010</span>
+HOOP_BITE_MAX = <span class="n">0.007</span>
+BOTTOM_T = <span class="n">0.022</span>
+CHIME = <span class="n">0.008</span>
+CROZE_BITE = <span class="n">0.0025</span>
+FLOOR_GAP_MAX = <span class="n">0.008</span>
+BAIL_R = <span class="n">0.008</span>
+BAIL_SEGS = <span class="n">24</span>
+BAIL_PIPE = <span class="n">8</span>
+EAR_Z = HEIGHT - <span class="n">0.016</span>
+RING_MAJOR = <span class="n">0.013</span>
+RING_MINOR = <span class="n">0.0035</span>
+BAIL_GAP_MAX = <span class="n">0.006</span>
+STAVE_ZMIN_MAX = <span class="n">0.001</span>
+SHORT_STAVES_LIFT = <span class="n">0.040</span>
+LIFT_Z = <span class="n">0.05</span>
+AREA_EPS = <span class="n">1e-10</span>
+DOUBLES_EPS = <span class="n">1e-5</span>
+ZMIN_EPS = <span class="n">1e-4</span>
+ZFIGHT_EPS = <span class="n">1e-4</span>
+ZFIGHT_COS = <span class="n">0.998</span>
+BODY_TOL = <span class="n">0.04</span>
+BODY_DIA = <span class="n">0.335</span>
+BODY_H = <span class="n">0.360</span>
+BBOX_TOL = <span class="n">0.015</span>
+OUTER_SIZE = (<span class="n">0.383</span>, <span class="n">0.346</span>, <span class="n">0.527</span>)
+
+BASE_TRIS_MIN = <span class="n">4000</span>
+BASE_TRIS_MAX = <span class="n">5800</span>
 LOD1_RATIO_MIN = <span class="n">0.32</span>
 LOD1_RATIO_MAX = <span class="n">0.62</span>
 LOD2_RATIO_MIN = <span class="n">0.10</span>
@@ -348,13 +398,15 @@ <h2>Source</h2>
 LOD1_TARGET = <span class="n">0.50</span>
 LOD2_TARGET = <span class="n">0.22</span>
 MATERIAL_COUNT = <span class="n">3</span>
+WOOD_FACES_MIN = <span class="n">350</span>
+METAL_FACES_MIN = <span class="n">180</span>
+ROPE_FACES_MIN = <span class="n">40</span>
 UV_EPS = <span class="n">1e-4</span>
 UV_OVERLAP_MAX = <span class="n">1e-5</span>
 COLLIDER_TRIS_MAX = <span class="n">420</span>
 BAKE_RES = <span class="n">256</span>
 CAGE_EXTRUSION = <span class="n">0.06</span>
-METAL_FACES_MIN = <span class="n">24</span>
-ROPE_FACES_MIN = <span class="n">12</span>
+STAVE_COUNT = N_STAVES
 
 WOOD_IDX = <span class="n">0</span>
 METAL_IDX = <span class="n">1</span>
@@ -376,7 +428,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()
@@ -389,69 +440,110 @@ <h2>Source</h2>
 
 <span class="k">def</span> radius_at(z):
     t = max(<span class="n">0.0</span>, min(<span class="n">1.0</span>, z / HEIGHT))
-    <span class="k">return</span> R_BOT + (R_TOP - R_BOT) * t
-
-
-<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">return</span> verts
-
-
-<span class="k">def</span> add_oriented_box(bm, a, b, scale_xy, mat_idx):
-    a = Vector(a)
-    b = Vector(b)
-    delta = b - a
-    length = delta.length
-    <span class="k">if</span> length &lt; <span class="n">1e-8</span>:
-        <span class="k">return</span> []
-    quat = Vector((<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">1.0</span>)).rotation_difference(delta.normalized())
-    eul = quat.to_euler(<span class="s">&quot;XYZ&quot;</span>)
-    <span class="k">return</span> add_box(
-        bm,
-        ((a + b) * <span class="n">0.5</span>),
-        (scale_xy[<span class="n">0</span>], scale_xy[<span class="n">1</span>], length),
-        mat_idx,
-        euler=(eul.x, eul.y, eul.z),
-    )
-
-
-<span class="k">def</span> add_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,
-    )
-    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">return</span> R_BOT + (R_TOP - R_BOT) * t + BULGE * math.sin(math.pi * t)
+
+
+<span class="k">def</span> stave_spans(n, gap_ang, jitter, seed):
+    rng = random.Random(seed)
+    weights = [<span class="n">1.0</span> + rng.uniform(-jitter, jitter) <span class="k">for</span> _ <span class="k">in</span> range(n)]
+    total = sum(weights)
+    usable = <span class="n">2.0</span> * math.pi - n * gap_ang
+    spans = []
+    a = <span class="n">0.0</span>
+    <span class="k">for</span> w <span class="k">in</span> weights:
+        width = usable * (w / total)
+        spans.append((a, a + width))
+        a += width + gap_ang
+    <span class="k">return</span> spans
+
+
+<span class="k">def</span> host_outer_r(u, z, spans, round_band):
+    r = radius_at(z)
+    <span class="k">if</span> round_band:
+        <span class="k">return</span> r
+    u = u % (<span class="n">2.0</span> * math.pi)
+    <span class="k">for</span> a0, a1 <span class="k">in</span> spans:
+        <span class="k">if</span> a0 - <span class="n">1e-9</span> &lt;= u &lt;= a1 + <span class="n">1e-9</span>:
+            mid = <span class="n">0.5</span> * (a0 + a1)
+            half = <span class="n">0.5</span> * (a1 - a0)
+            den = math.cos(u - mid)
+            <span class="k">if</span> abs(den) &lt; <span class="n">1e-4</span>:
+                <span class="k">return</span> r * math.cos(half)
+            <span class="k">return</span> r * math.cos(half) / den
+    <span class="k">return</span> r
+
+
+<span class="k">def</span> loft_cyclic(bm, sections, mat_idx):
+    vert_rings = [[bm.verts.new(p) <span class="k">for</span> p <span class="k">in</span> s] <span class="k">for</span> s <span class="k">in</span> sections]
+    m = len(vert_rings)
+    n = len(vert_rings[<span class="n">0</span>])
+    faces = []
+    <span class="k">for</span> k <span class="k">in</span> range(m):
+        a = vert_rings[k]
+        b = vert_rings[(k + <span class="n">1</span>) % m]
+        <span class="k">for</span> i <span class="k">in</span> range(n):
+            j = (i + <span class="n">1</span>) % n
+            face = bm.faces.new((a[i], a[j], b[j], b[i]))
+            face.material_index = mat_idx
+            faces.append(face)
+    <span class="k">return</span> [v <span class="k">for</span> ring <span class="k">in</span> vert_rings <span class="k">for</span> v <span class="k">in</span> ring], faces
 
 
-<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> loft_rings(bm, rings, mat_idx, cap_start=<span class="k">True</span>, cap_end=<span class="k">True</span>):
+    n = len(rings[<span class="n">0</span>])
+    <span class="k">for</span> k <span class="k">in</span> range(len(rings) - <span class="n">1</span>):
+        a, b = rings[k], rings[k + <span class="n">1</span>]
+        <span class="k">for</span> i <span class="k">in</span> range(n):
+            j = (i + <span class="n">1</span>) % n
+            face = bm.faces.new((a[i], a[j], b[j], b[i]))
+            face.material_index = mat_idx
+    <span class="k">if</span> cap_start:
+        fan_cap(bm, rings[<span class="n">0</span>], mat_idx, flip=<span class="k">True</span>)
+    <span class="k">if</span> cap_end:
+        fan_cap(bm, rings[-<span class="n">1</span>], mat_idx, flip=<span class="k">False</span>)
+
+
+<span class="k">def</span> fan_cap(bm, ring, mat_idx, flip=<span class="k">False</span>):
+    center = Vector((<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>))
+    <span class="k">for</span> v <span class="k">in</span> ring:
+        center += v.co
+    center /= len(ring)
+    hub = bm.verts.new(center)
+    n = len(ring)
+    <span class="k">for</span> i <span class="k">in</span> range(n):
+        vs = (hub, ring[i], ring[(i + <span class="n">1</span>) % n])
+        <span class="k">if</span> flip:
+            vs = (hub, vs[<span class="n">2</span>], vs[<span class="n">1</span>])
+        face = bm.faces.new(vs)
+        face.material_index = mat_idx
+    <span class="k">return</span> hub
+
+
+<span class="k">def</span> croze_xy(spans, z, bite, shrink=<span class="n">0.0</span>):
+    pts = []
+    <span class="k">for</span> a0, a1 <span class="k">in</span> spans:
+        <span class="k">for</span> u <span class="k">in</span> (a0, <span class="n">0.5</span> * (a0 + a1), a1):
+            r = host_outer_r(u, z, spans, <span class="k">False</span>) - STAVE_THICK + bite - shrink
+            pts.append((r * math.cos(u), r * math.sin(u)))
+    <span class="k">return</span> pts
+
+
+<span class="k">def</span> add_polygon_disk(bm, z0, z1, xy_ring, mat_idx):
+    rings = []
+    <span class="k">for</span> z <span class="k">in</span> (z0, z1):
+        ring = [bm.verts.new((x, y, z)) <span class="k">for</span> x, y <span class="k">in</span> xy_ring]
+        rings.append(ring)
+    a, b = rings
+    n = len(xy_ring)
+    <span class="k">for</span> i <span class="k">in</span> range(n):
+        j = (i + <span class="n">1</span>) % n
+        face = bm.faces.new((a[i], a[j], b[j], b[i]))
+        face.material_index = mat_idx
+    fan_cap(bm, a, mat_idx, flip=<span class="k">True</span>)
+    fan_cap(bm, b, mat_idx, flip=<span class="k">False</span>)
 
 
-<span class="k">def</span> add_rim(bm, loc, major, minor, mat_idx, euler=(<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>)):
-    n_major = <span class="n">12</span>
-    n_minor = <span class="n">6</span>
+<span class="k">def</span> add_torus(bm, loc, major, minor, n_major, n_minor, mat_idx, euler=(<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>)):
     rings = []
     <span class="k">for</span> i <span class="k">in</span> range(n_major):
         u = i * (<span class="n">2.0</span> * math.pi / n_major)
@@ -463,6 +555,7 @@ <h2>Source</h2>
             z = minor * math.sin(v)
             ring.append(bm.verts.new((x, y, z)))
         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):
@@ -471,7 +564,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:
@@ -479,6 +571,192 @@ <h2>Source</h2>
     <span class="k">return</span> verts
 
 
+<span class="k">def</span> add_pipe_curve(bm, points, radius, segs, mat_idx):
+    rings = []
+    n = len(points)
+    <span class="k">for</span> i, p <span class="k">in</span> enumerate(points):
+        p = Vector(p)
+        <span class="k">if</span> i &lt; n - <span class="n">1</span>:
+            tangent = (Vector(points[i + <span class="n">1</span>]) - p).normalized()
+        <span class="k">else</span>:
+            tangent = (p - Vector(points[i - <span class="n">1</span>])).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()
+        ring = []
+        <span class="k">for</span> k <span class="k">in</span> range(segs):
+            a = <span class="n">2.0</span> * math.pi * k / segs
+            ring.append(
+                bm.verts.new(
+                    p + side * (radius * math.cos(a)) + up * (radius * math.sin(a))
+                )
+            )
+        rings.append(ring)
+    loft_rings(bm, rings, mat_idx, cap_start=<span class="k">True</span>, cap_end=<span class="k">True</span>)
+
+
+<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">return</span> verts
+
+
+<span class="k">def</span> build_hoops(bm, spans, round_band):
+    <span class="k">for</span> z_mid <span class="k">in</span> HOOP_ZS:
+        z0 = z_mid - HOOP_H * <span class="n">0.5</span>
+        z1 = z_mid + HOOP_H * <span class="n">0.5</span>
+        c = HOOP_CHAMFER
+        sections = []
+        samples = []
+        <span class="k">for</span> a0, a1 <span class="k">in</span> spans:
+            samples.append(a0)
+            samples.append(<span class="n">0.5</span> * (a0 + a1))
+            samples.append(a1)
+        <span class="k">for</span> u <span class="k">in</span> samples:
+            cu, su = math.cos(u), math.sin(u)
+            r0 = host_outer_r(u, z0, spans, round_band)
+            r1 = host_outer_r(u, z1, spans, round_band)
+            profile = (
+                (r0 - HOOP_BITE, z0),
+                (r0 + HOOP_PROUD - c, z0),
+                (r0 + HOOP_PROUD, z0 + c),
+                (r1 + HOOP_PROUD, z1 - c),
+                (r1 + HOOP_PROUD - c, z1),
+                (r1 - HOOP_BITE, z1),
+            )
+            sections.append([Vector((r * cu, r * su, z)) <span class="k">for</span> r, z <span class="k">in</span> profile])
+        loft_cyclic(bm, sections, METAL_IDX)
+
+
+<span class="k">def</span> build_staves(bm, spans, z0, bevel_offset, bevel_segments):
+    zs = [HEIGHT * i / (N_RINGS - <span class="n">1</span>) <span class="k">for</span> i <span class="k">in</span> range(N_RINGS)]
+    stave_verts = []
+    <span class="k">for</span> a0, a1 <span class="k">in</span> spans:
+        outer = []
+        inner = []
+        <span class="k">for</span> z <span class="k">in</span> zs:
+            r = radius_at(z)
+            ov = (
+                bm.verts.new((r * math.cos(a0), r * math.sin(a0), z0 + z)),
+                bm.verts.new((r * math.cos(a1), r * math.sin(a1), z0 + z)),
+            )
+            ri = r - STAVE_THICK
+            iv = (
+                bm.verts.new((ri * math.cos(a0), ri * math.sin(a0), z0 + z)),
+                bm.verts.new((ri * math.cos(a1), ri * math.sin(a1), z0 + z)),
+            )
+            outer.append(ov)
+            inner.append(iv)
+            stave_verts.extend(ov)
+            stave_verts.extend(iv)
+        <span class="k">for</span> k <span class="k">in</span> range(N_RINGS - <span class="n">1</span>):
+            o0a, o0b = outer[k]
+            o1a, o1b = outer[k + <span class="n">1</span>]
+            i0a, i0b = inner[k]
+            i1a, i1b = inner[k + <span class="n">1</span>]
+            <span class="k">for</span> vs <span class="k">in</span> (
+                (o0a, o1a, o1b, o0b),
+                (i0b, i1b, i1a, i0a),
+                (o0a, i0a, i1a, o1a),
+                (o0b, o1b, i1b, i0b),
+            ):
+                face = bm.faces.new(vs)
+                face.material_index = WOOD_IDX
+        top = bm.faces.new((outer[-<span class="n">1</span>][<span class="n">0</span>], outer[-<span class="n">1</span>][<span class="n">1</span>], inner[-<span class="n">1</span>][<span class="n">1</span>], inner[-<span class="n">1</span>][<span class="n">0</span>]))
+        top.material_index = WOOD_IDX
+        bot = bm.faces.new((outer[<span class="n">0</span>][<span class="n">1</span>], outer[<span class="n">0</span>][<span class="n">0</span>], inner[<span class="n">0</span>][<span class="n">0</span>], inner[<span class="n">0</span>][<span class="n">1</span>]))
+        bot.material_index = WOOD_IDX
+    <span class="k">if</span> bevel_offset &gt; <span class="n">0.0</span>:
+        long_edges = []
+        seen = set()
+        <span class="k">for</span> v <span class="k">in</span> stave_verts:
+            <span class="k">for</span> e <span class="k">in</span> v.link_edges:
+                <span class="k">if</span> e <span class="k">in</span> seen:
+                    <span class="k">continue</span>
+                seen.add(e)
+                a, b = e.verts
+                <span class="k">if</span> abs(a.co.z - b.co.z) &gt; <span class="n">0.015</span>:
+                    long_edges.append(e)
+        <span class="k">if</span> long_edges:
+            bmesh.ops.bevel(
+                bm,
+                geom=long_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>,
+            )
+    <span class="k">return</span> stave_verts
+
+
+<span class="k">def</span> triangulate_ngons(bm):
+    faces = [f <span class="k">for</span> f <span class="k">in</span> bm.faces <span class="k">if</span> len(f.verts) &gt; <span class="n">4</span>]
+    <span class="k">if</span> faces:
+        bmesh.ops.triangulate(bm, faces=faces)
+
+
+<span class="k">def</span> add_ears_and_bail(bm, spans, float_handle):
+    <span class="s">&quot;&quot;&quot;Ear plates + flat rings (hole along Z) and a round bail through them.
+
+    Ring centres sit on the stave outer at EAR_Z. The bail is a semicircle
+    in XZ whose ends are vertical, so they pass through the rings. A
+    smaller semicircle is the falsifier: the bar sits on the ring.
+    &quot;&quot;&quot;</span>
+    u_l = <span class="n">0.5</span> * (spans[<span class="n">0</span>][<span class="n">0</span>] + spans[<span class="n">0</span>][<span class="n">1</span>])
+    u_r = <span class="n">0.5</span> * (spans[N_STAVES // <span class="n">2</span>][<span class="n">0</span>] + spans[N_STAVES // <span class="n">2</span>][<span class="n">1</span>])
+    r_l = host_outer_r(u_l, EAR_Z, spans, <span class="k">False</span>)
+    r_r = host_outer_r(u_r, EAR_Z, spans, <span class="k">False</span>)
+    plate_t = <span class="n">0.007</span>
+    plate_h = <span class="n">0.036</span>
+    plate_w = <span class="n">0.028</span>
+    plate_z = HEIGHT - plate_h * <span class="n">0.5</span> - <span class="n">0.006</span>
+    x_l = -(r_l + plate_t * <span class="n">0.5</span>)
+    x_r = r_r + plate_t * <span class="n">0.5</span>
+    ring_x_l = -(r_l + plate_t + RING_MAJOR * <span class="n">0.25</span>)
+    ring_x_r = r_r + plate_t + RING_MAJOR * <span class="n">0.25</span>
+    <span class="k">for</span> x <span class="k">in</span> (x_l, x_r):
+        add_box(
+            bm,
+            (x, <span class="n">0.0</span>, plate_z),
+            (plate_t, plate_w, plate_h),
+            METAL_IDX,
+        )
+    <span class="k">for</span> x <span class="k">in</span> (ring_x_l, ring_x_r):
+        add_torus(
+            bm,
+            (x, <span class="n">0.0</span>, EAR_Z),
+            RING_MAJOR,
+            RING_MINOR,
+            <span class="n">12</span>,
+            <span class="n">6</span>,
+            METAL_IDX,
+            euler=(<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>),
+        )
+    rx = <span class="n">0.5</span> * (abs(ring_x_l) + abs(ring_x_r))
+    <span class="k">if</span> float_handle:
+        rx *= <span class="n">0.72</span>
+        z0 = EAR_Z + <span class="n">0.035</span>
+    <span class="k">else</span>:
+        z0 = EAR_Z
+    pts = []
+    <span class="k">for</span> i <span class="k">in</span> range(BAIL_SEGS + <span class="n">1</span>):
+        t = math.pi * i / BAIL_SEGS
+        pts.append((rx * math.cos(t), <span class="n">0.0</span>, z0 + rx * math.sin(t)))
+    add_pipe_curve(bm, pts, BAIL_R, BAIL_PIPE, ROPE_IDX)
+
+
 <span class="k">def</span> pack_uvs(bm, margin=<span class="n">0.08</span>):
     uv = bm.loops.layers.uv.new(<span class="s">&quot;UVMap&quot;</span>)
     faces = list(bm.faces)
@@ -495,9 +773,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
@@ -522,122 +798,32 @@ <h2>Source</h2>
             )
 
 
-<span class="k">def</span> build_bucket_mesh(name, bevel_offset, bevel_segments):
+<span class="k">def</span> build_bucket_mesh(
+    name,
+    bevel_offset,
+    bevel_segments,
+    short_staves=<span class="k">False</span>,
+    float_handle=<span class="k">False</span>,
+    round_band=<span class="k">False</span>,
+    float_bottom=<span class="k">False</span>,
+):
     bm = bmesh.new()
-    stave_verts = []
-    hoop_faces = set()
-    rope_faces = set()
+    gap_ang = GAP_M / max(R_TOP, <span class="n">0.1</span>)
+    spans = stave_spans(N_STAVES, gap_ang, STAVE_JITTER, STAVE_SEED)
+    z0 = SHORT_STAVES_LIFT <span class="k">if</span> short_staves <span class="k">else</span> <span class="n">0.0</span>
     <span class="k">try</span>:
-        zs = [HEIGHT * i / (N_RINGS - <span class="n">1</span>) <span class="k">for</span> i <span class="k">in</span> range(N_RINGS)]
-        <span class="k">for</span> i <span class="k">in</span> range(N_STAVES):
-            a0 = <span class="n">2.0</span> * math.pi * i / N_STAVES
-            a1 = <span class="n">2.0</span> * math.pi * (i + <span class="n">1.0</span> - STAVE_GAP) / N_STAVES
-            outer = []
-            inner = []
-            <span class="k">for</span> z <span class="k">in</span> zs:
-                r = radius_at(z)
-                ov = (
-                    bm.verts.new((r * math.cos(a0), r * math.sin(a0), z)),
-                    bm.verts.new((r * math.cos(a1), r * math.sin(a1), z)),
-                )
-                ri = r - STAVE_THICK
-                iv = (
-                    bm.verts.new((ri * math.cos(a0), ri * math.sin(a0), z)),
-                    bm.verts.new((ri * math.cos(a1), ri * math.sin(a1), z)),
-                )
-                outer.append(ov)
-                inner.append(iv)
-                stave_verts.extend(ov)
-                stave_verts.extend(iv)
-            <span class="k">for</span> k <span class="k">in</span> range(N_RINGS - <span class="n">1</span>):
-                o0a, o0b = outer[k]
-                o1a, o1b = outer[k + <span class="n">1</span>]
-                i0a, i0b = inner[k]
-                i1a, i1b = inner[k + <span class="n">1</span>]
-                <span class="k">for</span> vs <span class="k">in</span> (
-                    (o0a, o1a, o1b, o0b),
-                    (i0b, i1b, i1a, i0a),
-                    (o0a, i0a, i1a, o1a),
-                    (o0b, o1b, i1b, i0b),
-                ):
-                    face = bm.faces.new(vs)
-                    face.material_index = WOOD_IDX
-            <span class="c"># Rim only — no top lid. Interior stays open.</span>
-            top = bm.faces.new((outer[-<span class="n">1</span>][<span class="n">0</span>], outer[-<span class="n">1</span>][<span class="n">1</span>], inner[-<span class="n">1</span>][<span class="n">1</span>], inner[-<span class="n">1</span>][<span class="n">0</span>]))
-            top.material_index = WOOD_IDX
-            bot = bm.faces.new((outer[<span class="n">0</span>][<span class="n">1</span>], outer[<span class="n">0</span>][<span class="n">0</span>], inner[<span class="n">0</span>][<span class="n">0</span>], inner[<span class="n">0</span>][<span class="n">1</span>]))
-            bot.material_index = 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> stave_verts <span class="k">for</span> e <span class="k">in</span> v.link_edges})
-            bmesh.ops.bevel(
-                bm,
-                geom=edges,
-                offset=bevel_offset,
-                segments=bevel_segments,
-                profile=<span class="n">0.5</span>,
-                affect=<span class="s">&quot;EDGES&quot;</span>,
-                clamp_overlap=<span class="k">True</span>,
-            )
-
-        <span class="c"># Bottom seated inside the hull so the basin actually holds.</span>
-        add_cylinder(
-            bm,
-            (<span class="n">0.0</span>, <span class="n">0.0</span>, BOTTOM_T / <span class="n">2.0</span>),
-            R_BOT - STAVE_THICK * <span class="n">0.35</span>,
-            BOTTOM_T,
-            <span class="n">16</span>,
+        build_staves(bm, spans, z0, bevel_offset, bevel_segments)
+        bot_z0 = CHIME
+        bot_z1 = CHIME + BOTTOM_T
+        shrink = <span class="n">0.022</span> <span class="k">if</span> float_bottom <span class="k">else</span> <span class="n">0.0</span>
+        add_polygon_disk(
+            bm, bot_z0, bot_z1,
+            croze_xy(spans, <span class="n">0.5</span> * (bot_z0 + bot_z1), CROZE_BITE, shrink),
             WOOD_IDX,
         )
-
-        <span class="k">for</span> z <span class="k">in</span> HOOP_ZS:
-            before = set(bm.faces)
-            add_cylinder(
-                bm,
-                (<span class="n">0.0</span>, <span class="n">0.0</span>, z),
-                radius_at(z) + HOOP_PAD,
-                HOOP_H,
-                <span class="n">20</span>,
-                METAL_IDX,
-            )
-            hoop_faces.update(set(bm.faces) - before)
-
-        ear_x = R_TOP + <span class="n">0.006</span>
-        ear_z = HEIGHT - <span class="n">0.018</span>
-        <span class="k">for</span> sign <span class="k">in</span> (-<span class="n">1.0</span>, <span class="n">1.0</span>):
-            before = set(bm.faces)
-            add_box(
-                bm,
-                (sign * ear_x, <span class="n">0.0</span>, ear_z),
-                (<span class="n">0.028</span>, <span class="n">0.036</span>, <span class="n">0.048</span>),
-                METAL_IDX,
-            )
-            add_rim(
-                bm,
-                (sign * (ear_x + <span class="n">0.006</span>), <span class="n">0.0</span>, ear_z + <span class="n">0.012</span>),
-                <span class="n">0.016</span>,
-                <span class="n">0.005</span>,
-                METAL_IDX,
-                euler=(math.radians(<span class="n">90.0</span>), <span class="n">0.0</span>, <span class="n">0.0</span>),
-            )
-            hoop_faces.update(set(bm.faces) - before)
-
-        bail_major = ear_x + <span class="n">0.004</span>
-        bail_pts = []
-        <span class="k">for</span> i <span class="k">in</span> range(BAIL_SEGS + <span class="n">1</span>):
-            t = math.pi * i / BAIL_SEGS
-            bail_pts.append(
-                (
-                    bail_major * math.cos(t),
-                    <span class="n">0.0</span>,
-                    ear_z + <span class="n">0.012</span> + bail_major * math.sin(t),
-                )
-            )
-        before = set(bm.faces)
-        <span class="k">for</span> a, b <span class="k">in</span> zip(bail_pts, bail_pts[<span class="n">1</span>:]):
-            add_oriented_box(bm, a, b, (BAIL_R * <span class="n">2.0</span>, BAIL_R * <span class="n">2.0</span>), ROPE_IDX)
-        rope_faces.update(set(bm.faces) - before)
-
+        build_hoops(bm, spans, round_band)
+        add_ears_and_bail(bm, spans, float_handle)
+        triangulate_ngons(bm)
         pack_uvs(bm)
         bmesh.ops.recalc_face_normals(bm, faces=list(bm.faces))
         <span class="k">for</span> face <span class="k">in</span> bm.faces:
@@ -647,12 +833,6 @@ <h2>Source</h2>
             <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>):
                     edge.smooth = <span class="k">False</span>
-        <span class="k">for</span> f <span class="k">in</span> hoop_faces:
-            <span class="k">if</span> f.is_valid:
-                f.material_index = METAL_IDX
-        <span class="k">for</span> f <span class="k">in</span> rope_faces:
-            <span class="k">if</span> f.is_valid:
-                f.material_index = ROPE_IDX
         me = bpy.data.meshes.new(name)
         bm.to_mesh(me)
         me.update()
@@ -663,32 +843,44 @@ <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, rope):
     mats = obj.data.materials
-    <span class="k">if</span> len(mats) == <span class="n">0</span>:
-        mats.append(wood)
-        mats.append(metal)
-        mats.append(rope)
-        <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
-    <span class="k">if</span> len(mats) == <span class="n">2</span>:
-        mats.append(rope)
-    <span class="k">else</span>:
-        mats[<span class="n">2</span>] = rope
+    wanted = (wood, metal, rope)
+    <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):
@@ -699,6 +891,17 @@ <h2>Source</h2>
     <span class="k">return</span> (min(xs), min(ys), min(zs), max(xs), max(ys), max(zs))
 
 
+<span class="k">def</span> face_area(me, poly):
+    verts = [me.vertices[i].co <span class="k">for</span> i <span class="k">in</span> poly.vertices]
+    <span class="k">if</span> len(verts) &lt; <span class="n">3</span>:
+        <span class="k">return</span> <span class="n">0.0</span>
+    acc = Vector((<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>))
+    origin = verts[<span class="n">0</span>]
+    <span class="k">for</span> a, b <span class="k">in</span> zip(verts[<span class="n">1</span>:], verts[<span class="n">2</span>:]):
+        acc += (a - origin).cross(b - origin)
+    <span class="k">return</span> <span class="n">0.5</span> * acc.length
+
+
 <span class="k">def</span> uv_stats(mesh):
     uv = mesh.uv_layers.active
     <span class="k">if</span> uv <span class="k">is</span> <span class="k">None</span>:
@@ -724,6 +927,239 @@ <h2>Source</h2>
     <span class="k">return</span> min(us), min(vs), max(us), max(vs), overlap, len(aabbs)
 
 
+<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)
+    staves = []
+    <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)
+        dz = 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>:
+            staves.append(a)
+    stave_z = min((a[<span class="n">2</span>] <span class="k">for</span> a <span class="k">in</span> staves), default=<span class="n">99.0</span>)
+    <span class="k">return</span> {<span class="s">&quot;staves&quot;</span>: len(staves), <span class="s">&quot;stave_z&quot;</span>: stave_z}
+
+
+<span class="k">def</span> hoop_seat(me, spans):
+    groups = shells(me)
+    bites = []
+    <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.06</span> <span class="k">or</span> max(dx, dy) &lt; <span class="n">0.20</span>:
+            <span class="k">continue</span>
+        rs = [math.hypot(me.vertices[i].co.x, me.vertices[i].co.y) <span class="k">for</span> i <span class="k">in</span> g]
+        <span class="k">for</span> i, r <span class="k">in</span> zip(g, rs):
+            p = me.vertices[i].co
+            u = math.atan2(p.y, p.x)
+            host = host_outer_r(u, p.z, spans, <span class="k">False</span>)
+            <span class="k">if</span> r &gt; host + <span class="n">0.0005</span>:
+                <span class="k">continue</span>
+            bites.append(host - r)
+    <span class="k">if</span> <span class="k">not</span> bites:
+        <span class="k">return</span> <span class="n">0.05</span>, <span class="n">0.05</span>
+    <span class="k">return</span> min(bites), max(bites)
+
+
+<span class="k">def</span> floor_gap(me):
+    groups = shells(me)
+    floors, staves = [], []
+    <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)
+        dz = a[<span class="n">5</span>] - a[<span class="n">2</span>]
+        r = <span class="n">0.25</span> * ((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> dz &lt; <span class="n">0.05</span> <span class="k">and</span> r &gt; <span class="n">0.08</span>:
+            floors.append(g)
+        <span class="k">elif</span> dz &gt; <span class="n">0.20</span>:
+            staves.append(g)
+    <span class="k">if</span> <span class="k">not</span> floors <span class="k">or</span> <span class="k">not</span> staves:
+        <span class="k">return</span> <span class="n">99.0</span>
+    bm_s = bmesh.new()
+    <span class="k">try</span>:
+        bm_s.from_mesh(me)
+        keep = set()
+        <span class="k">for</span> g <span class="k">in</span> staves:
+            keep.update(g)
+        drop = [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> keep <span class="k">for</span> v <span class="k">in</span> f.verts)]
+        <span class="k">if</span> drop:
+            bmesh.ops.delete(bm_s, geom=drop, context=<span class="s">&quot;FACES&quot;</span>)
+        <span class="k">if</span> <span class="k">not</span> bm_s.faces:
+            <span class="k">return</span> <span class="n">99.0</span>
+        tree = BVHTree.FromBMesh(bm_s)
+        worst = <span class="n">0.0</span>
+        <span class="k">for</span> g <span class="k">in</span> floors:
+            rmax = max(math.hypot(me.vertices[i].co.x, me.vertices[i].co.y) <span class="k">for</span> i <span class="k">in</span> g)
+            <span class="k">for</span> i <span class="k">in</span> g:
+                p = me.vertices[i].co
+                <span class="k">if</span> math.hypot(p.x, p.y) &lt; <span class="n">0.90</span> * rmax:
+                    <span class="k">continue</span>
+                loc, _n, _i, dist = tree.find_nearest(p)
+                <span class="k">if</span> loc <span class="k">is</span> <span class="k">None</span>:
+                    <span class="k">continue</span>
+                worst = max(worst, dist)
+        <span class="k">return</span> worst
+    <span class="k">finally</span>:
+        bm_s.free()
+
+
+<span class="k">def</span> bail_join(me):
+    groups = shells(me)
+    rings, bails = [], []
+    <span class="k">for</span> g <span class="k">in</span> groups:
+        a = shell_aabb(me, g)
+        dx, dy, dz = a[<span class="n">3</span>] - a[<span class="n">0</span>], a[<span class="n">4</span>] - a[<span class="n">1</span>], a[<span class="n">5</span>] - a[<span class="n">2</span>]
+        mat = mat_of(me, g)
+        <span class="k">if</span> mat == METAL_IDX <span class="k">and</span> max(dx, dy, dz) &lt; <span class="n">0.08</span> <span class="k">and</span> a[<span class="n">2</span>] &gt; <span class="n">0.25</span>:
+            rings.append(g)
+        <span class="k">elif</span> mat == ROPE_IDX:
+            bails.append(g)
+    <span class="k">if</span> <span class="k">not</span> rings <span class="k">or</span> <span class="k">not</span> bails:
+        <span class="k">return</span> <span class="n">99.0</span>
+    bm_b = bmesh.new()
+    <span class="k">try</span>:
+        bm_b.from_mesh(me)
+        keep = set()
+        <span class="k">for</span> g <span class="k">in</span> bails:
+            keep.update(g)
+        drop = [f <span class="k">for</span> f <span class="k">in</span> bm_b.faces <span class="k">if</span> <span class="k">not</span> all(v.index <span class="k">in</span> keep <span class="k">for</span> v <span class="k">in</span> f.verts)]
+        <span class="k">if</span> drop:
+            bmesh.ops.delete(bm_b, geom=drop, context=<span class="s">&quot;FACES&quot;</span>)
+        <span class="k">if</span> <span class="k">not</span> bm_b.faces:
+            <span class="k">return</span> <span class="n">99.0</span>
+        tree = BVHTree.FromBMesh(bm_b)
+        best = <span class="n">99.0</span>
+        <span class="k">for</span> g <span class="k">in</span> rings:
+            <span class="k">for</span> i <span class="k">in</span> g:
+                p = me.vertices[i].co
+                loc, _n, _idx, dist = tree.find_nearest(p)
+                <span class="k">if</span> loc <span class="k">is</span> <span class="k">None</span>:
+                    <span class="k">continue</span>
+                best = min(best, dist)
+        <span class="k">return</span> best
+    <span class="k">finally</span>:
+        bm_b.free()
+
+
+<span class="k">def</span> body_plan(me):
+    groups = shells(me)
+    xs, ys, z0s, z1s = [], [], [], []
+    <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)
+        <span class="k">if</span> a[<span class="n">5</span>] - a[<span class="n">2</span>] &lt; <span class="n">0.20</span>:
+            <span class="k">continue</span>
+        xs.extend((a[<span class="n">0</span>], a[<span class="n">3</span>]))
+        ys.extend((a[<span class="n">1</span>], a[<span class="n">4</span>]))
+        z0s.append(a[<span class="n">2</span>])
+        z1s.append(a[<span class="n">5</span>])
+    <span class="k">if</span> <span class="k">not</span> xs:
+        <span class="k">return</span> <span class="n">0.0</span>, <span class="n">0.0</span>
+    dia = <span class="n">0.5</span> * ((max(xs) - min(xs)) + (max(ys) - min(ys)))
+    <span class="k">return</span> dia, max(z1s) - min(z0s)
+
+
+<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>, HEIGHT * <span class="n">0.5</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)
@@ -737,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>:
@@ -749,6 +1184,14 @@ <h2>Source</h2>
             bmesh.ops.delete(bm, geom=interior, context=<span class="s">&quot;VERTS&quot;</span>)
         <span class="k">if</span> unused:
             bmesh.ops.delete(bm, geom=unused, context=<span class="s">&quot;VERTS&quot;</span>)
+        bmesh.ops.dissolve_limit(
+            bm,
+            angle_limit=math.radians(<span class="n">10.0</span>),
+            verts=list(bm.verts),
+            edges=list(bm.edges),
+            delimit={<span class="s">&quot;NORMAL&quot;</span>},
+        )
+        bmesh.ops.triangulate(bm, faces=list(bm.faces))
         bm.to_mesh(mesh)
         mesh.update()
     <span class="k">finally</span>:
@@ -760,7 +1203,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;BucketNrm&quot;</span>, size, size, alpha=<span class="k">True</span>, float_buffer=<span class="k">False</span>)
@@ -775,7 +1217,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>
@@ -800,7 +1241,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:
@@ -816,19 +1256,50 @@ <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_staves=<span class="k">False</span>,
+    float_handle=<span class="k">False</span>,
+    round_band=<span class="k">False</span>,
+    float_bottom=<span class="k">False</span>,
+):
     bpy.ops.wm.read_factory_settings(use_empty=<span class="k">True</span>)
-    low = build_bucket_mesh(<span class="s">&quot;BucketLow&quot;</span>, bevel_offset=<span class="n">0.003</span>, bevel_segments=<span class="n">2</span>)
-    high = build_bucket_mesh(<span class="s">&quot;BucketHigh&quot;</span>, bevel_offset=<span class="n">0.003</span>, bevel_segments=<span class="n">4</span>)
-    wood = principled(<span class="s">&quot;BucketWood&quot;</span>, (<span class="n">0.46</span>, <span class="n">0.24</span>, <span class="n">0.09</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;BucketMetal&quot;</span>, (<span class="n">0.58</span>, <span class="n">0.56</span>, <span class="n">0.52</span>, <span class="n">1.0</span>), <span class="n">1.0</span>, <span class="n">0.24</span>)
-    rope = principled(<span class="s">&quot;BucketRope&quot;</span>, (<span class="n">0.42</span>, <span class="n">0.32</span>, <span class="n">0.18</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.78</span>)
+    flags = dict(
+        short_staves=short_staves,
+        float_handle=float_handle,
+        round_band=round_band,
+        float_bottom=float_bottom,
+    )
+    low = build_bucket_mesh(<span class="s">&quot;BucketLow&quot;</span>, <span class="n">0.003</span>, <span class="n">2</span>, **flags)
+    high = build_bucket_mesh(<span class="s">&quot;BucketHigh&quot;</span>, <span class="n">0.003</span>, <span class="n">4</span>, **flags)
+    wood = principled(
+        <span class="s">&quot;BucketWood&quot;</span>, (<span class="n">0.46</span>, <span class="n">0.24</span>, <span class="n">0.09</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.52</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;BucketHoop&quot;</span>, (<span class="n">0.55</span>, <span class="n">0.53</span>, <span class="n">0.50</span>, <span class="n">1.0</span>), <span class="n">1.0</span>, <span class="n">0.28</span>,
+        noise_scale=<span class="n">5.0</span>, wear=(<span class="n">0.35</span>, <span class="n">0.32</span>, <span class="n">0.28</span>, <span class="n">1.0</span>),
+    )
+    rope = principled(
+        <span class="s">&quot;BucketRope&quot;</span>, (<span class="n">0.42</span>, <span class="n">0.32</span>, <span class="n">0.18</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.72</span>,
+        noise_scale=<span class="n">9.0</span>, wear=(<span class="n">0.30</span>, <span class="n">0.22</span>, <span class="n">0.12</span>, <span class="n">1.0</span>),
+    )
     assign_slots(low, wood, metal, rope)
     assign_slots(high, wood, metal, rope)
+    <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;bucket 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>
 
+    spans = stave_spans(N_STAVES, GAP_M / max(R_TOP, <span class="n">0.1</span>), STAVE_JITTER, STAVE_SEED)
     base_tris = triangle_count(low.data)
     mats = [s <span class="k">for</span> s <span class="k">in</span> low.data.materials <span class="k">if</span> s <span class="k">is</span> <span class="k">not</span> <span class="k">None</span>]
     nmat = len(mats)
@@ -842,6 +1313,23 @@ <h2>Source</h2>
     size_x = bb[<span class="n">3</span>] - bb[<span class="n">0</span>]
     size_y = bb[<span class="n">4</span>] - bb[<span class="n">1</span>]
     size_z = bb[<span class="n">5</span>] - bb[<span class="n">2</span>]
+    hyg = hygiene_audit(low.data)
+    zf = zfight_pairs(low.data)
+    sup = support_audit(low.data)
+    bite_min, bite_max = hoop_seat(low.data, spans)
+    bjoin = bail_join(low.data)
+    fgap = floor_gap(low.data)
+    dia, ht = body_plan(low.data)
+    print(
+        <span class="s">f&quot;</span><span class="s">measured hygiene loose_v=</span>{hyg[<span class="s">&#x27;loose_v&#x27;</span>]}<span class="s"> loose_e=</span>{hyg[<span class="s">&#x27;loose_e&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">nonman=</span>{hyg[<span class="s">&#x27;nonman&#x27;</span>]}<span class="s"> zero_area=</span>{hyg[<span class="s">&#x27;zero_area&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">doubles=</span>{hyg[<span class="s">&#x27;doubles&#x27;</span>]}<span class="s"> ngons=</span>{hyg[<span class="s">&#x27;ngons&#x27;</span>]}<span class="s"> zfight=</span>{zf}<span class="s">&quot;</span>
+    )
+    print(
+        <span class="s">f&quot;</span><span class="s">measured staves=</span>{sup[<span class="s">&#x27;staves&#x27;</span>]}<span class="s"> stave_z=</span>{sup[<span class="s">&#x27;stave_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">hoop_bite=</span>{bite_min:<span class="s">.5f</span>}<span class="s">..</span>{bite_max:<span class="s">.5f</span>}<span class="s"> bail_join=</span>{bjoin:<span class="s">.5f</span>}<span class="s"> </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">floor_gap=</span>{fgap:<span class="s">.5f</span>}<span class="s"> body=</span>{dia:<span class="s">.4f</span>}<span class="s">x</span>{ht:<span class="s">.4f</span>}<span class="s">&quot;</span>
+    )
 
     img, tex = setup_bake_image(low, wood)
     <span class="k">if</span> img <span class="k">is</span> <span class="k">None</span>:
@@ -856,7 +1344,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_bucket_mesh(<span class="s">&quot;BucketColSrc&quot;</span>, bevel_offset=<span class="n">0.0</span>, bevel_segments=<span class="n">1</span>)
+    collider_src = build_bucket_mesh(<span class="s">&quot;BucketColSrc&quot;</span>, <span class="n">0.0</span>, <span class="n">1</span>)
     collider = convex_hull_collider(collider_src, <span class="s">&quot;BucketCollider&quot;</span>)
     bpy.data.objects.remove(collider_src, do_unlink=<span class="k">True</span>)
     col_tris = triangle_count(collider.data)
@@ -870,9 +1358,7 @@ <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>
-    )
+    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>
@@ -900,6 +1386,11 @@ <h2>Source</h2>
             <span class="s">f&quot;</span><span class="s">material slots </span>{nmat}<span class="s"> distinct </span>{distinct_mats}<span class="s"> != </span>{MATERIAL_COUNT}<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> idx_counts.get(METAL_IDX, <span class="n">0</span>) &lt; METAL_FACES_MIN:
         <span class="k">return</span> fail(
             <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>,
@@ -953,6 +1444,58 @@ <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"> </span><span class="s">&quot;</span>
+            <span class="s">&quot;(--stray-vert is the designed fail)&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;staves&quot;</span>] != STAVE_COUNT <span class="k">or</span> sup[<span class="s">&quot;stave_z&quot;</span>] &gt; STAVE_ZMIN_MAX:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">named staves </span>{sup[<span class="s">&#x27;staves&#x27;</span>]}<span class="s"> z=</span>{sup[<span class="s">&#x27;stave_z&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">&quot;(--short-staves 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> bjoin &gt; BAIL_GAP_MAX:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">bail-ear gap </span>{bjoin:<span class="s">.5f</span>}<span class="s"> &gt; </span>{BAIL_GAP_MAX}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">&quot;(--float-handle 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> fgap &gt; FLOOR_GAP_MAX:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">floor-croze gap </span>{fgap:<span class="s">.5f</span>}<span class="s"> &gt; </span>{FLOOR_GAP_MAX}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">&quot;(--float-bottom 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> bite_min &lt; HOOP_BITE_MIN <span class="k">or</span> bite_max &gt; HOOP_BITE_MAX:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">hoop bite </span>{bite_min:<span class="s">.5f</span>}<span class="s">..</span>{bite_max:<span class="s">.5f</span>}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">f&quot;</span><span class="s">outside [</span>{HOOP_BITE_MIN}<span class="s">, </span>{HOOP_BITE_MAX}<span class="s">] </span><span class="s">&quot;</span>
+            <span class="s">&quot;(--round-band 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(dia - BODY_DIA) &gt; BODY_TOL <span class="k">or</span> abs(ht - BODY_H) &gt; BODY_TOL:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">body plan </span>{dia:<span class="s">.4f</span>}<span class="s">x</span>{ht:<span class="s">.4f</span>}<span class="s"> off </span>{BODY_DIA}<span class="s">x</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
 
 
@@ -965,15 +1508,13 @@ <h2>Source</h2>
     nt.links.new(nrm.outputs[<span class="s">&quot;Normal&quot;</span>], bsdf.inputs[<span class="s">&quot;Normal&quot;</span>])
 
 
-<span class="k">def</span> render_still(low, wood, tex, path, engine):
+<span class="k">def</span> render_still(low, wood, _tex, path, engine):
     scene = bpy.context.scene
-    wire_normal(wood, tex)
     <span class="k">for</span> ob <span class="k">in</span> list(scene.objects):
         <span class="k">if</span> ob.type == <span class="s">&quot;MESH&quot;</span> <span class="k">and</span> ob != low:
             ob.hide_render = <span class="k">True</span>
             ob.hide_viewport = <span class="k">True</span>
 
-    <span class="c"># Three-quarter from above so the open basin and bottom read.</span>
     low.rotation_euler.z = math.radians(-<span class="n">38.0</span>)
     low.rotation_euler.x = math.radians(<span class="n">8.0</span>)
 
@@ -1021,10 +1562,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.05</span>, -<span class="n">1.42</span>, <span class="n">1.12</span>)
+    cam.location = (<span class="n">0.94</span>, -<span class="n">1.28</span>, <span class="n">1.16</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.30</span>)
+    aim.location = (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.28</span>)
     scene.collection.objects.link(aim)
     con = cam.constraints.new(<span class="s">&quot;TRACK_TO&quot;</span>)
     con.target = aim
@@ -1067,14 +1608,24 @@ <h2>Source</h2>
     p = argparse.ArgumentParser()
     p.add_argument(<span class="s">&quot;--output&quot;</span>, default=<span class="k">None</span>)
     p.add_argument(<span class="s">&quot;--engine&quot;</span>, default=<span class="s">&quot;eevee&quot;</span>, choices=(<span class="s">&quot;eevee&quot;</span>, <span class="s">&quot;cycles&quot;</span>))
-    p.add_argument(
-        <span class="s">&quot;--skip-decimate&quot;</span>,
-        action=<span class="s">&quot;store_true&quot;</span>,
-        help=<span class="s">&quot;falsification: skip the LOD DECIMATE stage&quot;</span>,
-    )
+    p.add_argument(<span class="s">&quot;--skip-decimate&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--stray-vert&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--lift-z&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--short-staves&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--float-handle&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--float-bottom&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--round-band&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_staves=args.short_staves,
+        float_handle=args.float_handle,
+        round_band=args.round_band,
+        float_bottom=args.float_bottom,
+    )
     <span class="k">if</span> code:
         <span class="k">return</span> code
     <span class="k">if</span> args.output:
diff --git a/showcase/gallery.json b/showcase/gallery.json
index 93d22b7..7cff48a 100644
--- a/showcase/gallery.json
+++ b/showcase/gallery.json
@@ -32,8 +32,8 @@
     {
       "name": "wooden-barrel",
       "dir": "showcase/wooden-barrel",
-      "teaches": "A procedural staved barrel through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.",
-      "witnessesFix": "Recomputed: 4312 tris, two materials with 88 metal hoop faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.719×0.719×0.880 m, LOD ratios in band, convex collider 372 tris, non-empty glTF. --skip-decimate exits 9 on the LOD1 ratio budget.",
+      "teaches": "A procedural wine-cask with croze-seated heads and chord-lofted hoops through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.",
+      "witnessesFix": "Recomputed: 7216 tris, two materials with 2512 wood and 1440 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.722×0.714×0.880 m, 20 grounded staves, hoop bite 0.003 m, head-croze gap 0.007 m, LOD ratios in band, convex collider 238 tris, non-empty glTF. --skip-decimate exits 9; --round-band exits 18 on the hoop-seat budget.",
       "hero": "docs/gallery/assets/wooden-barrel-hero.webp",
       "preview": "showcase/wooden-barrel/preview.webp",
       "tags": [
@@ -248,8 +248,8 @@
     {
       "name": "wooden-bucket",
       "dir": "showcase/wooden-bucket",
-      "teaches": "A procedural coopered wooden bucket with overlapping staves, a sealed bottom, iron hoops, and a rope bail through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.",
-      "witnessesFix": "Recomputed: 4272 tris, three materials with 222 metal and 72 rope faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.402×0.345×0.544 m, LOD ratios in band, convex collider 390 tris, non-empty glTF. --skip-decimate exits 9 on the LOD1 ratio budget.",
+      "teaches": "A procedural coopered pail with a croze-seated floor, chord-lofted hoops, and a round bail through the ear rings through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.",
+      "witnessesFix": "Recomputed: 4872 tris, three materials with 1424 wood, 1020 metal, and 208 rope faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.383×0.346×0.527 m, 16 grounded staves, hoop bite 0.0025 m, bail-ear gap 0.0013 m, LOD ratios in band, convex collider 302 tris, non-empty glTF. --skip-decimate exits 9; --float-handle exits 17 on the bail-ear budget.",
       "hero": "docs/gallery/assets/wooden-bucket-hero.webp",
       "preview": "showcase/wooden-bucket/preview.webp",
       "tags": [
diff --git a/showcase/wooden-barrel/README.md b/showcase/wooden-barrel/README.md
index 2a3534f..f0201e3 100644
--- a/showcase/wooden-barrel/README.md
+++ b/showcase/wooden-barrel/README.md
@@ -1,9 +1,16 @@
 # Wooden barrel
 
-A showcase piece, not an example. Procedural staved barrel (bulged staves,
-four iron hoops, top and bottom heads) 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 wine-cask (20 staves with
+seeded width jitter, heads seated in a croze below a chime, iron hoops
+lofted on the stave faces, a bung) then the shipped pipeline: unique-cell
+UVs, Cycles high-to-low normal bake, LOD chain, convex collider, Unity
+glTF export.
+
+Hoops evaluate the same `host_outer_r` chord as the stave flats.
+`--round-band` is the falsifier: a circle of `radius_at(z)` instead of
+the chord, which is what made the old capped cylinder float off every
+face. Heads follow the inner stave polygon, not a circle, so they fill
+the croze instead of leaving triangular slots at every joint.
 
 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 +28,82 @@ materials, UVs, evaluated LOD, collider, or export file.
 
 | Axis | Declared | Measured (4.5.11 / 5.1.2 / 5.2.1) |
 | --- | --- | --- |
-| Base triangles | 4200–4450 | 4312 / 4312 / 4312 |
+| Base triangles | 6000–8500 | 7216 / 7216 / 7216 |
 | 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, ≥16 metal hoop faces | 2 slots, 88 hoop faces |
+| LOD2 ratio | 0.10–0.35 of base | 0.2198 / 0.2198 / 0.2198 |
+| Materials | exactly 2 distinct; ≥400 wood, ≥200 metal faces | 2 slots; 2512 / 1440 |
 | UVs | in `0..1`, AABB overlap ≤ 1e-5 | in range, overlap 0 |
-| Outer AABB | (0.719, 0.719, 0.880) m ± 0.01 | (0.7194, 0.7194, 0.8800), zmin 0 |
-| Collider tris | ≤ 400 | 372 |
-| Export | written, size > 0 | 327564 / 327564 / 327556 bytes |
+| Outer AABB | (0.722, 0.714, 0.880) m ± 0.015 | (0.7220, 0.7142, 0.8800), zmin 0 |
+| Collider tris | ≤ 400 | 238 |
+| Export | written, size > 0 | 544140 / 544140 / 544124 bytes |
+
+Base triangles rose from **4312 to 7216** in the quality pass: 12 identical
+staves with 5 mm daylight and circular hoops became 20 jittered staves,
+8-ring bulge, chord-seated hoops, polygonal croze heads, and a bung.
+
+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. Stave-width jitter uses fixed seed 17. Export byte counts
+differ by 16 B on 5.2.1 (glTF serializer), not a gated axis.
+
+### Hygiene
+
+Recomputed from the generated mesh, not asserted about the script.
+
+| Axis | Declared | Measured (all three) |
+| --- | --- | --- |
+| Non-manifold edges | 0 | 0 |
+| Loose verts / edges | 0 / 0 | 0 / 0 |
+| Doubles merged at 1e-5 | 0 | 0 |
+| Zero-area faces | 0 | 0 |
+| N-gons | 0 | 0 |
+| Coplanar disjoint face pairs | 0 | 0 |
+| Grounded: `zmin` | within 1e-4 of 0 | 0.0000 |
+| Named supports: 20 staves | each `zmin` ≤ 0.001 | 20, stave_z 0.00000 |
+| Body plan | 0.714 m dia × 0.880 m high ± 0.04 | 0.7142 × 0.8800 |
+
+### Joint fit and seat
+
+| Axis | Declared | Measured (all three) |
+| --- | --- | --- |
+| Head-croze rim BVH gap | ≤ 0.010 m | 0.00698 |
+| Hoop bite (host r − inner hoop r) | 0.0012–0.008 m | 0.00300 |
+
+### Falsifiers
 
-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.
+Each violates one named budget. All six were run on 4.5.11, 5.1.2 and
+5.2.1 and returned the same code on each.
 
-`--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.
+| 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-staves` | named stave supports at Z=0 | 16 |
+| `--float-head` | head-croze gap | 17 |
+| `--round-band` | hoop bite band | 18 |
 
 ## Run
 
 ```bash
 blender --background --python wooden_barrel.py --
 blender --background --python wooden_barrel.py -- --skip-decimate
+blender --background --python wooden_barrel.py -- --stray-vert
+blender --background --python wooden_barrel.py -- --lift-z
+blender --background --python wooden_barrel.py -- --short-staves
+blender --background --python wooden_barrel.py -- --float-head
+blender --background --python wooden_barrel.py -- --round-band
 blender --background --python wooden_barrel.py -- --output barrel.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 +112,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 hoop 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 +122,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 stave floats |
+| 17 | Joint fit: head-croze gap (`--float-head`) |
+| 18 | Seat: hoop bite band (`--round-band`) |
+| 19 | Body diameter or height off the stated real-world size |
diff --git a/showcase/wooden-barrel/preview.webp b/showcase/wooden-barrel/preview.webp
index 2f70c8e..39891ff 100644
Binary files a/showcase/wooden-barrel/preview.webp and b/showcase/wooden-barrel/preview.webp differ
diff --git a/showcase/wooden-barrel/wooden_barrel.py b/showcase/wooden-barrel/wooden_barrel.py
index 6974703..45ce78f 100644
--- a/showcase/wooden-barrel/wooden_barrel.py
+++ b/showcase/wooden-barrel/wooden_barrel.py
@@ -1,14 +1,22 @@
 """Game-ready wooden barrel — a showcase piece, not an example.
 
-Asserts budget conformance of a procedural staved barrel after composing
-shipped pipeline pieces: bmesh construction, UVs, two materials, high-to-low
-normal bake, LOD chain, convex collider, Unity glTF export.
+Asserts budget conformance of a procedural staved barrel (tight staves
+with seeded width jitter, heads seated in a croze, iron hoops lofted on
+the stave faces, a bung) after composing shipped pipeline pieces: bmesh
+construction, UVs, two materials, high-to-low normal bake, LOD chain,
+convex collider, Unity glTF export.
+
+The old piece was a 12-gon with 5 mm daylight between identical staves
+and circular capped-cylinder hoops that floated off every stave face.
 
 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-staves`` named stave
+supports, ``--float-head`` head-croze joint-fit, ``--round-band`` hoop
+seat (hoop generated on a circle instead of the stave chords).
 
-No RNG. Construction is closed-form. DECIMATE COLLAPSE triangle counts
+Fixed seed 17 for stave-width jitter. DECIMATE COLLAPSE triangle counts
 are not byte-identical across Blender versions — the LOD gate is a
 ratio band, not an exact count.
 
@@ -19,17 +27,16 @@
 import argparse
 import math
 import os
+import random
 import sys
 import tempfile
 import traceback
 
 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,22 +44,46 @@
 sys.dont_write_bytecode = True
 import gallery_framing  # noqa: E402
 
+# Wine-cask scale: 88 cm tall, 72 cm at the bulge.
 HEIGHT = 0.88
 R_END = 0.27
 R_MID = 0.36
-N_STAVES = 12
-STAVE_THICK = 0.030
-N_RINGS = 5
-STAVE_GAP = 0.05
-HOOP_ZS = (0.10, 0.28, 0.60, 0.78)
-HOOP_H = 0.042
-HOOP_PAD = 0.014
-LID_T = 0.030
-BBOX_TOL = 0.01
-OUTER_SIZE = (0.719, 0.719, 0.880)
-
-BASE_TRIS_MIN = 4200
-BASE_TRIS_MAX = 4450
+N_STAVES = 20
+STAVE_THICK = 0.028
+N_RINGS = 8
+STAVE_SEED = 17
+STAVE_JITTER = 0.08
+GAP_M = 0.0012
+HOOP_ZS = (0.085, 0.255, 0.625, 0.795)
+HOOP_H = 0.030
+HOOP_PROUD = 0.007
+HOOP_BITE = 0.003
+HOOP_CHAMFER = 0.003
+HOOP_BITE_MIN = 0.0012
+HOOP_BITE_MAX = 0.008
+LID_T = 0.028
+CHIME = 0.014
+CROZE_BITE = 0.003
+HEAD_GAP_MAX = 0.010
+BUNG_Z = 0.44
+BUNG_R = 0.022
+BUNG_SEGS = 24
+STAVE_ZMIN_MAX = 0.001
+SHORT_STAVES_LIFT = 0.045
+LIFT_Z = 0.05
+AREA_EPS = 1e-10
+DOUBLES_EPS = 1e-5
+ZMIN_EPS = 1e-4
+ZFIGHT_EPS = 1e-4
+ZFIGHT_COS = 0.998
+BODY_TOL = 0.04
+BODY_DIA = 0.714
+BODY_H = 0.880
+BBOX_TOL = 0.015
+OUTER_SIZE = (0.722, 0.714, 0.880)
+
+BASE_TRIS_MIN = 6000
+BASE_TRIS_MAX = 8500
 LOD1_RATIO_MIN = 0.32
 LOD1_RATIO_MAX = 0.62
 LOD2_RATIO_MIN = 0.10
@@ -60,11 +91,14 @@
 LOD1_TARGET = 0.50
 LOD2_TARGET = 0.22
 MATERIAL_COUNT = 2
+WOOD_FACES_MIN = 400
+METAL_FACES_MIN = 200
 UV_EPS = 1e-4
 UV_OVERLAP_MAX = 1e-5
 COLLIDER_TRIS_MAX = 400
 BAKE_RES = 256
 CAGE_EXTRUSION = 0.05
+STAVE_COUNT = N_STAVES
 
 WOOD_IDX = 0
 METAL_IDX = 1
@@ -85,7 +119,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()
@@ -100,30 +133,228 @@ def radius_at(z):
     return R_END + (R_MID - R_END) * math.sin(math.pi * z / HEIGHT)
 
 
-def add_cone(bm, loc, radius1, radius2, depth, segments, mat_idx, euler=(0.0, 0.0, 0.0)):
+def stave_spans(n, gap_ang, jitter, seed):
+    rng = random.Random(seed)
+    weights = [1.0 + rng.uniform(-jitter, jitter) for _ in range(n)]
+    total = sum(weights)
+    usable = 2.0 * math.pi - n * gap_ang
+    spans = []
+    a = 0.0
+    for w in weights:
+        width = usable * (w / total)
+        spans.append((a, a + width))
+        a += width + gap_ang
+    return spans
+
+
+def host_outer_r(u, z, spans, round_band):
+    """Radial distance of the outer stave face at angle u.
+
+    One function owns the surface. The hoop, the head croze and the
+    assertions all evaluate it. ``round_band`` is the falsifier: a circle
+    of ``radius_at(z)`` instead of the stave chord, which is what made
+    the old cylinder float off every flat.
+    """
+    r = radius_at(z)
+    if round_band:
+        return r
+    u = u % (2.0 * math.pi)
+    for a0, a1 in spans:
+        if a0 - 1e-9 <= u <= a1 + 1e-9:
+            mid = 0.5 * (a0 + a1)
+            half = 0.5 * (a1 - a0)
+            den = math.cos(u - mid)
+            if abs(den) < 1e-4:
+                return r * math.cos(half)
+            return r * math.cos(half) / den
+    return r
+
+
+def loft_cyclic(bm, sections, mat_idx):
+    vert_rings = [[bm.verts.new(p) for p in s] for s in sections]
+    m = len(vert_rings)
+    n = len(vert_rings[0])
+    faces = []
+    for k in range(m):
+        a = vert_rings[k]
+        b = vert_rings[(k + 1) % m]
+        for i in range(n):
+            j = (i + 1) % n
+            face = bm.faces.new((a[i], a[j], b[j], b[i]))
+            face.material_index = mat_idx
+            faces.append(face)
+    return [v for ring in vert_rings for v in ring], faces
+
+
+def fan_cap(bm, ring, mat_idx, flip=False):
+    center = Vector((0.0, 0.0, 0.0))
+    for v in ring:
+        center += v.co
+    center /= len(ring)
+    hub = bm.verts.new(center)
+    faces = []
+    n = len(ring)
+    for i in range(n):
+        vs = (hub, ring[i], ring[(i + 1) % n])
+        if flip:
+            vs = (hub, vs[2], vs[1])
+        face = bm.faces.new(vs)
+        face.material_index = mat_idx
+        faces.append(face)
+    return hub, faces
+
+
+def croze_xy(spans, z, bite, shrink=0.0):
+    """Head outline = inner stave chords plus croze bite.
+
+    A circle leaves a triangular slot at every stave joint. Sampling
+    each stave at both edges and the mid-face, then connecting in
+    order, makes the head follow the same host as the hoops.
+    """
+    pts = []
+    for a0, a1 in spans:
+        for u in (a0, 0.5 * (a0 + a1), a1):
+            r = host_outer_r(u, z, spans, False) - STAVE_THICK + bite - shrink
+            pts.append((r * math.cos(u), r * math.sin(u)))
+    return pts
+
+
+def add_polygon_disk(bm, z0, z1, xy_ring, mat_idx):
+    rings = []
+    for z in (z0, z1):
+        ring = [bm.verts.new((x, y, z)) for x, y in xy_ring]
+        rings.append(ring)
+    a, b = rings
+    n = len(xy_ring)
+    for i in range(n):
+        j = (i + 1) % n
+        face = bm.faces.new((a[i], a[j], b[j], b[i]))
+        face.material_index = mat_idx
+    fan_cap(bm, a, mat_idx, flip=True)
+    fan_cap(bm, b, mat_idx, flip=False)
+
+
+def add_bung(bm, u, z, spans):
+    r_out = host_outer_r(u, z, spans, False)
+    cu, su = math.cos(u), math.sin(u)
+    radial = Vector((cu, su, 0.0))
+    origin = radial * (r_out - STAVE_THICK * 0.45)
     geo = bmesh.ops.create_cone(
         bm,
         cap_ends=True,
-        cap_tris=False,
-        segments=segments,
-        radius1=radius1,
-        radius2=radius2,
-        depth=depth,
+        cap_tris=True,
+        segments=BUNG_SEGS,
+        radius1=BUNG_R,
+        radius2=BUNG_R * 0.92,
+        depth=STAVE_THICK + 0.018,
     )
     verts = list(geo["verts"])
-    rot = Euler(euler).to_matrix()
-    origin = Vector(loc)
+    quat = Vector((0.0, 0.0, 1.0)).rotation_difference(radial)
+    rot = quat.to_matrix()
     for v in verts:
-        v.co = rot @ v.co + origin
-    bm.faces.ensure_lookup_table()
+        v.co = rot @ v.co + origin + Vector((0.0, 0.0, z))
     faces = {f for v in verts for f in v.link_faces}
     for f in faces:
-        f.material_index = mat_idx
+        f.material_index = WOOD_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 build_hoops(bm, spans, round_band):
+    faces_all = []
+    for z_mid in HOOP_ZS:
+        z0 = z_mid - HOOP_H * 0.5
+        z1 = z_mid + HOOP_H * 0.5
+        c = HOOP_CHAMFER
+        sections = []
+        samples = []
+        for a0, a1 in spans:
+            samples.append(a0)
+            samples.append(0.5 * (a0 + a1))
+            samples.append(a1)
+        for u in samples:
+            cu, su = math.cos(u), math.sin(u)
+            r0 = host_outer_r(u, z0, spans, round_band)
+            r1 = host_outer_r(u, z1, spans, round_band)
+            profile = (
+                (r0 - HOOP_BITE, z0),
+                (r0 + HOOP_PROUD - c, z0),
+                (r0 + HOOP_PROUD, z0 + c),
+                (r1 + HOOP_PROUD, z1 - c),
+                (r1 + HOOP_PROUD - c, z1),
+                (r1 - HOOP_BITE, z1),
+            )
+            sections.append([Vector((r * cu, r * su, z)) for r, z in profile])
+        _verts, faces = loft_cyclic(bm, sections, METAL_IDX)
+        faces_all.extend(faces)
+    return faces_all
+
+
+def build_staves(bm, spans, z0, bevel_offset, bevel_segments):
+    zs = [HEIGHT * i / (N_RINGS - 1) for i in range(N_RINGS)]
+    stave_verts = []
+    for a0, a1 in spans:
+        outer = []
+        inner = []
+        for z in zs:
+            r = radius_at(z)
+            ov = (
+                bm.verts.new((r * math.cos(a0), r * math.sin(a0), z0 + z)),
+                bm.verts.new((r * math.cos(a1), r * math.sin(a1), z0 + z)),
+            )
+            ri = r - STAVE_THICK
+            iv = (
+                bm.verts.new((ri * math.cos(a0), ri * math.sin(a0), z0 + z)),
+                bm.verts.new((ri * math.cos(a1), ri * math.sin(a1), z0 + z)),
+            )
+            outer.append(ov)
+            inner.append(iv)
+            stave_verts.extend(ov)
+            stave_verts.extend(iv)
+        for k in range(N_RINGS - 1):
+            o0a, o0b = outer[k]
+            o1a, o1b = outer[k + 1]
+            i0a, i0b = inner[k]
+            i1a, i1b = inner[k + 1]
+            for vs in (
+                (o0a, o1a, o1b, o0b),
+                (i0b, i1b, i1a, i0a),
+                (o0a, i0a, i1a, o1a),
+                (o0b, o1b, i1b, i0b),
+            ):
+                face = bm.faces.new(vs)
+                face.material_index = WOOD_IDX
+        top = bm.faces.new((outer[-1][0], outer[-1][1], inner[-1][1], inner[-1][0]))
+        top.material_index = WOOD_IDX
+        bot = bm.faces.new((outer[0][1], outer[0][0], inner[0][0], inner[0][1]))
+        bot.material_index = WOOD_IDX
+    if bevel_offset > 0.0:
+        long_edges = []
+        seen = set()
+        for v in stave_verts:
+            for e in v.link_edges:
+                if e in seen:
+                    continue
+                seen.add(e)
+                a, b = e.verts
+                if abs(a.co.z - b.co.z) > 0.02:
+                    long_edges.append(e)
+        if long_edges:
+            bmesh.ops.bevel(
+                bm,
+                geom=long_edges,
+                offset=bevel_offset,
+                segments=bevel_segments,
+                profile=0.5,
+                affect="EDGES",
+                clamp_overlap=True,
+            )
+    return stave_verts
+
+
+def triangulate_ngons(bm):
+    faces = [f for f in bm.faces if len(f.verts) > 4]
+    if faces:
+        bmesh.ops.triangulate(bm, faces=faces)
 
 
 def pack_uvs(bm, margin=0.08):
@@ -142,9 +373,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
@@ -169,78 +398,38 @@ def pack_uvs(bm, margin=0.08):
             )
 
 
-def build_barrel_mesh(name, bevel_offset, bevel_segments):
+def build_barrel_mesh(
+    name,
+    bevel_offset,
+    bevel_segments,
+    short_staves=False,
+    float_head=False,
+    round_band=False,
+):
     bm = bmesh.new()
-    stave_verts = []
+    gap_ang = GAP_M / R_MID
+    spans = stave_spans(N_STAVES, gap_ang, STAVE_JITTER, STAVE_SEED)
+    z0 = SHORT_STAVES_LIFT if short_staves else 0.0
     try:
-        zs = [HEIGHT * i / (N_RINGS - 1) for i in range(N_RINGS)]
-        for i in range(N_STAVES):
-            a0 = 2.0 * math.pi * i / N_STAVES
-            a1 = 2.0 * math.pi * (i + 1.0 - STAVE_GAP) / N_STAVES
-            outer = []
-            inner = []
-            for z in zs:
-                r = radius_at(z)
-                ov = (
-                    bm.verts.new((r * math.cos(a0), r * math.sin(a0), z)),
-                    bm.verts.new((r * math.cos(a1), r * math.sin(a1), z)),
-                )
-                ri = r - STAVE_THICK
-                iv = (
-                    bm.verts.new((ri * math.cos(a0), ri * math.sin(a0), z)),
-                    bm.verts.new((ri * math.cos(a1), ri * math.sin(a1), z)),
-                )
-                outer.append(ov)
-                inner.append(iv)
-                stave_verts.extend(ov)
-                stave_verts.extend(iv)
-            for k in range(N_RINGS - 1):
-                o0a, o0b = outer[k]
-                o1a, o1b = outer[k + 1]
-                i0a, i0b = inner[k]
-                i1a, i1b = inner[k + 1]
-                for vs in (
-                    (o0a, o1a, o1b, o0b),
-                    (i0b, i1b, i1a, i0a),
-                    (o0a, i0a, i1a, o1a),
-                    (o0b, o1b, i1b, i0b),
-                ):
-                    face = bm.faces.new(vs)
-                    face.material_index = WOOD_IDX
-            top = bm.faces.new((outer[-1][0], outer[-1][1], inner[-1][1], inner[-1][0]))
-            top.material_index = WOOD_IDX
-            bot = bm.faces.new((outer[0][1], outer[0][0], inner[0][0], inner[0][1]))
-            bot.material_index = WOOD_IDX
-
-        if bevel_offset > 0.0:
-            edges = list({e for v in stave_verts for e in v.link_edges})
-            bmesh.ops.bevel(
-                bm,
-                geom=edges,
-                offset=bevel_offset,
-                segments=bevel_segments,
-                profile=0.5,
-                affect="EDGES",
-                clamp_overlap=True,
-            )
-
-        add_cylinder(bm, (0.0, 0.0, LID_T / 2.0), R_END - 0.012, LID_T, 16, WOOD_IDX)
-        add_cylinder(
-            bm, (0.0, 0.0, HEIGHT - LID_T / 2.0), R_END - 0.012, LID_T, 16, WOOD_IDX,
+        build_staves(bm, spans, z0, bevel_offset, bevel_segments)
+        shrink = 0.028 if float_head else 0.0
+        bot_z0 = CHIME
+        bot_z1 = CHIME + LID_T
+        top_z0 = HEIGHT - CHIME - LID_T
+        top_z1 = HEIGHT - CHIME
+        add_polygon_disk(
+            bm, bot_z0, bot_z1,
+            croze_xy(spans, 0.5 * (bot_z0 + bot_z1), CROZE_BITE, shrink),
+            WOOD_IDX,
         )
-        hoop_faces = set()
-        for z in HOOP_ZS:
-            before = set(bm.faces)
-            add_cylinder(
-                bm,
-                (0.0, 0.0, z),
-                radius_at(z) + HOOP_PAD,
-                HOOP_H,
-                20,
-                METAL_IDX,
-            )
-            hoop_faces.update(set(bm.faces) - before)
-
+        add_polygon_disk(
+            bm, top_z0, top_z1,
+            croze_xy(spans, 0.5 * (top_z0 + top_z1), CROZE_BITE, shrink),
+            WOOD_IDX,
+        )
+        add_bung(bm, 0.5 * (spans[0][0] + spans[0][1]), BUNG_Z, spans)
+        build_hoops(bm, spans, round_band)
+        triangulate_ngons(bm)
         pack_uvs(bm)
         bmesh.ops.recalc_face_normals(bm, faces=list(bm.faces))
         for face in bm.faces:
@@ -250,9 +439,6 @@ def build_barrel_mesh(name, bevel_offset, bevel_segments):
             if edge.is_manifold and len(edge.link_faces) == 2:
                 if edge.calc_face_angle() > math.radians(35.0):
                     edge.smooth = False
-        for f in hoop_faces:
-            if f.is_valid:
-                f.material_index = METAL_IDX
         me = bpy.data.meshes.new(name)
         bm.to_mesh(me)
         me.update()
@@ -263,29 +449,44 @@ def build_barrel_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 hoop faces onto wood.
     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):
@@ -296,6 +497,17 @@ def world_bbox(obj):
     return (min(xs), min(ys), min(zs), max(xs), max(ys), max(zs))
 
 
+def face_area(me, poly):
+    verts = [me.vertices[i].co for i in poly.vertices]
+    if len(verts) < 3:
+        return 0.0
+    acc = Vector((0.0, 0.0, 0.0))
+    origin = verts[0]
+    for a, b in zip(verts[1:], verts[2:]):
+        acc += (a - origin).cross(b - origin)
+    return 0.5 * acc.length
+
+
 def uv_stats(mesh):
     uv = mesh.uv_layers.active
     if uv is None:
@@ -321,6 +533,204 @@ def uv_stats(mesh):
     return min(us), min(vs), max(us), max(vs), overlap, len(aabbs)
 
 
+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)
+    staves = []
+    for g in groups:
+        if mat_of(me, g) != WOOD_IDX:
+            continue
+        a = shell_aabb(me, g)
+        dz = a[5] - a[2]
+        if dz > 0.50:
+            staves.append(a)
+    stave_z = min((a[2] for a in staves), default=99.0)
+    return {"staves": len(staves), "stave_z": stave_z}
+
+
+def hoop_seat(me, spans):
+    groups = shells(me)
+    bites = []
+    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.08 or max(dx, dy) < 0.40:
+            continue
+        rs = [math.hypot(me.vertices[i].co.x, me.vertices[i].co.y) for i in g]
+        for i, r in zip(g, rs):
+            p = me.vertices[i].co
+            u = math.atan2(p.y, p.x)
+            host = host_outer_r(u, p.z, spans, False)
+            if r > host + 0.0005:
+                continue
+            bites.append(host - r)
+    if not bites:
+        return 0.05, 0.05
+    return min(bites), max(bites)
+
+
+def head_gap(me, spans):
+    groups = shells(me)
+    heads, staves = [], []
+    for g in groups:
+        if mat_of(me, g) != WOOD_IDX:
+            continue
+        a = shell_aabb(me, g)
+        dz = a[5] - a[2]
+        r = 0.25 * ((a[3] - a[0]) + (a[4] - a[1]))
+        if dz < 0.06 and r > 0.15:
+            heads.append(g)
+        elif dz > 0.50:
+            staves.append(g)
+    if not heads or not staves:
+        return 99.0
+    bm_s = bmesh.new()
+    try:
+        bm_s.from_mesh(me)
+        keep = set()
+        for g in staves:
+            keep.update(g)
+        drop = [f for f in bm_s.faces if not all(v.index in keep for v in f.verts)]
+        if drop:
+            bmesh.ops.delete(bm_s, geom=drop, context="FACES")
+        if not bm_s.faces:
+            return 99.0
+        tree = BVHTree.FromBMesh(bm_s)
+        worst = 0.0
+        for g in heads:
+            a = shell_aabb(me, g)
+            if a[2] > 0.2:
+                continue
+            rmax = max(math.hypot(me.vertices[i].co.x, me.vertices[i].co.y) for i in g)
+            for i in g:
+                p = me.vertices[i].co
+                if math.hypot(p.x, p.y) < 0.90 * rmax:
+                    continue
+                loc, _n, _i, dist = tree.find_nearest(p)
+                if loc is None:
+                    continue
+                worst = max(worst, dist)
+        return worst
+    finally:
+        bm_s.free()
+
+
+def body_plan(me):
+    groups = shells(me)
+    xs, ys, z0s, z1s = [], [], [], []
+    for g in groups:
+        if mat_of(me, g) != WOOD_IDX:
+            continue
+        a = shell_aabb(me, g)
+        if a[5] - a[2] < 0.50:
+            continue
+        xs.extend((a[0], a[3]))
+        ys.extend((a[1], a[4]))
+        z0s.append(a[2])
+        z1s.append(a[5])
+    if not xs:
+        return 0.0, 0.0
+    dia = 0.5 * ((max(xs) - min(xs)) + (max(ys) - min(ys)))
+    return dia, max(z1s) - min(z0s)
+
+
+def add_stray_vert(me):
+    bm = bmesh.new()
+    try:
+        bm.from_mesh(me)
+        bm.verts.new((0.0, 0.0, HEIGHT * 0.5))
+        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)
@@ -334,7 +744,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:
@@ -346,6 +755,14 @@ def convex_hull_collider(obj, name):
             bmesh.ops.delete(bm, geom=interior, context="VERTS")
         if unused:
             bmesh.ops.delete(bm, geom=unused, context="VERTS")
+        bmesh.ops.dissolve_limit(
+            bm,
+            angle_limit=math.radians(10.0),
+            verts=list(bm.verts),
+            edges=list(bm.edges),
+            delimit={"NORMAL"},
+        )
+        bmesh.ops.triangulate(bm, faces=list(bm.faces))
         bm.to_mesh(mesh)
         mesh.update()
     finally:
@@ -357,7 +774,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("BarrelNrm", size, size, alpha=True, float_buffer=False)
@@ -372,7 +788,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"
@@ -397,7 +812,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:
@@ -413,18 +827,44 @@ def export_unity(path, objects):
     )
 
 
-def check(skip_decimate):
+def check(
+    skip_decimate,
+    lift_z=False,
+    stray_vert=False,
+    short_staves=False,
+    float_head=False,
+    round_band=False,
+):
     bpy.ops.wm.read_factory_settings(use_empty=True)
-    low = build_barrel_mesh("BarrelLow", bevel_offset=0.006, bevel_segments=2)
-    high = build_barrel_mesh("BarrelHigh", bevel_offset=0.006, bevel_segments=4)
-    wood = principled("BarrelWood", (0.48, 0.22, 0.07, 1.0), 0.0, 0.50)
-    metal = principled("BarrelMetal", (0.62, 0.60, 0.56, 1.0), 1.0, 0.22)
+    flags = dict(
+        short_staves=short_staves,
+        float_head=float_head,
+        round_band=round_band,
+    )
+    low = build_barrel_mesh("BarrelLow", 0.004, 2, **flags)
+    high = build_barrel_mesh("BarrelHigh", 0.004, 4, **flags)
+    wood = principled(
+        "BarrelWood", (0.48, 0.22, 0.07, 1.0), 0.0, 0.50,
+        noise_scale=7.0, wear=(0.28, 0.14, 0.05, 1.0),
+    )
+    metal = principled(
+        "BarrelHoop", (0.55, 0.53, 0.50, 1.0), 1.0, 0.28,
+        noise_scale=5.0, wear=(0.35, 0.32, 0.28, 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("barrel mesh did not build", 3), None, None, None, None, None
 
+    spans = stave_spans(N_STAVES, GAP_M / R_MID, STAVE_JITTER, STAVE_SEED)
     base_tris = triangle_count(low.data)
     mats = [s for s in low.data.materials if s is not None]
     nmat = len(mats)
@@ -438,6 +878,22 @@ def check(skip_decimate):
     size_x = bb[3] - bb[0]
     size_y = bb[4] - bb[1]
     size_z = bb[5] - bb[2]
+    hyg = hygiene_audit(low.data)
+    zf = zfight_pairs(low.data)
+    sup = support_audit(low.data)
+    bite_min, bite_max = hoop_seat(low.data, spans)
+    hgap = head_gap(low.data, spans)
+    dia, ht = body_plan(low.data)
+    print(
+        f"measured hygiene loose_v={hyg['loose_v']} loose_e={hyg['loose_e']} "
+        f"nonman={hyg['nonman']} zero_area={hyg['zero_area']} "
+        f"doubles={hyg['doubles']} ngons={hyg['ngons']} zfight={zf}"
+    )
+    print(
+        f"measured staves={sup['staves']} stave_z={sup['stave_z']:.5f} "
+        f"hoop_bite={bite_min:.5f}..{bite_max:.5f} head_gap={hgap:.5f} "
+        f"body={dia:.4f}x{ht:.4f}"
+    )
 
     img, tex = setup_bake_image(low, wood)
     if img is None:
@@ -452,7 +908,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_barrel_mesh("BarrelColSrc", bevel_offset=0.0, bevel_segments=1)
+    collider_src = build_barrel_mesh("BarrelColSrc", 0.0, 1)
     collider = convex_hull_collider(collider_src, "BarrelCollider")
     bpy.data.objects.remove(collider_src, do_unlink=True)
     col_tris = triangle_count(collider.data)
@@ -466,9 +922,7 @@ 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}"
-    )
+    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}"
@@ -496,9 +950,14 @@ def check(skip_decimate):
             f"material slots {nmat} distinct {distinct_mats} != {MATERIAL_COUNT}",
             5,
         ), None, None, None, None, None
-    if idx_counts.get(METAL_IDX, 0) < 16:
+    if idx_counts.get(WOOD_IDX, 0) < WOOD_FACES_MIN:
         return fail(
-            f"metal hoop faces {idx_counts.get(METAL_IDX, 0)} < 16",
+            f"wood faces {idx_counts.get(WOOD_IDX, 0)} < {WOOD_FACES_MIN}",
+            5,
+        ), None, None, None, None, None
+    if idx_counts.get(METAL_IDX, 0) < METAL_FACES_MIN:
+        return fail(
+            f"metal hoop faces {idx_counts.get(METAL_IDX, 0)} < {METAL_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:
@@ -511,6 +970,32 @@ def check(skip_decimate):
             f"UV AABB overlap {overlap:.6f} > {UV_OVERLAP_MAX}",
             7,
         ), 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} "
+            "(--stray-vert is the designed fail)",
+            15,
+        ), None, None, None, None, None
+    if (
+        abs(bb[2]) > ZMIN_EPS
+        or sup["staves"] != STAVE_COUNT
+        or sup["stave_z"] > STAVE_ZMIN_MAX
+    ):
+        return fail(
+            f"zmin {bb[2]:.6f} staves={sup['staves']} stave_z={sup['stave_z']:.5f} "
+            "(--lift-z / --short-staves is the designed fail)",
+            16,
+        ), None, None, None, None, None
     if (
         abs(size_x - OUTER_SIZE[0]) > BBOX_TOL
         or abs(size_y - OUTER_SIZE[1]) > BBOX_TOL
@@ -544,6 +1029,24 @@ 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 hgap > HEAD_GAP_MAX:
+        return fail(
+            f"head-croze gap {hgap:.5f} > {HEAD_GAP_MAX} "
+            "(--float-head is the designed fail)",
+            17,
+        ), None, None, None, None, None
+    if bite_min < HOOP_BITE_MIN or bite_max > HOOP_BITE_MAX:
+        return fail(
+            f"hoop bite {bite_min:.5f}..{bite_max:.5f} "
+            f"outside [{HOOP_BITE_MIN}, {HOOP_BITE_MAX}] "
+            "(--round-band is the designed fail)",
+            18,
+        ), None, None, None, None, None
+    if abs(dia - BODY_DIA) > BODY_TOL or abs(ht - BODY_H) > BODY_TOL:
+        return fail(
+            f"body plan {dia:.4f}x{ht:.4f} off {BODY_DIA}x{BODY_H}",
+            19,
+        ), None, None, None, None, None
     return 0, low, high, wood, tex, collider
 
 
@@ -556,9 +1059,8 @@ def wire_normal(mat, tex):
     nt.links.new(nrm.outputs["Normal"], bsdf.inputs["Normal"])
 
 
-def render_still(low, wood, tex, path, engine):
+def render_still(low, wood, _tex, path, engine):
     scene = bpy.context.scene
-    wire_normal(wood, tex)
     for ob in list(scene.objects):
         if ob.type == "MESH" and ob != low:
             ob.hide_render = True
@@ -657,14 +1159,22 @@ def main():
     p = argparse.ArgumentParser()
     p.add_argument("--output", default=None)
     p.add_argument("--engine", default="eevee", choices=("eevee", "cycles"))
-    p.add_argument(
-        "--skip-decimate",
-        action="store_true",
-        help="falsification: skip the LOD DECIMATE stage",
-    )
+    p.add_argument("--skip-decimate", action="store_true")
+    p.add_argument("--stray-vert", action="store_true")
+    p.add_argument("--lift-z", action="store_true")
+    p.add_argument("--short-staves", action="store_true")
+    p.add_argument("--float-head", action="store_true")
+    p.add_argument("--round-band", 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_staves=args.short_staves,
+        float_head=args.float_head,
+        round_band=args.round_band,
+    )
     if code:
         return code
     if args.output:
diff --git a/showcase/wooden-bucket/README.md b/showcase/wooden-bucket/README.md
index d60ab42..4c48f5d 100644
--- a/showcase/wooden-bucket/README.md
+++ b/showcase/wooden-bucket/README.md
@@ -1,9 +1,18 @@
 # Wooden bucket
 
-A showcase piece, not an example. Procedural coopered bucket (overlapping
-staves, sealed bottom, iron hoops, ears, rope bail) 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 coopered pail (16 staves
+with seeded width jitter, a bottom seated in a croze above a chime,
+iron hoops lofted on the stave faces, ear plates and rings, a round
+rope bail through the rings) then the shipped pipeline: unique-cell
+UVs, Cycles high-to-low normal bake, LOD chain, convex collider, Unity
+glTF export.
+
+Hoops evaluate the same `host_outer_r` chord as the stave flats.
+`--round-band` is the falsifier: a circle of `radius_at(z)` instead of
+the chord. The floor follows the inner stave polygon. Ear plates sit on
+the outer stave face below the rim; the bail is a semicircle whose ends
+pass through the rings. `--float-handle` shrinks that semicircle so the
+bar sits on the ring; `--float-bottom` shrinks the floor out of the croze.
 
 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 +30,87 @@ materials, UVs, evaluated LOD, collider, or export file.
 
 | Axis | Declared | Measured (4.5.11 / 5.1.2 / 5.2.1) |
 | --- | --- | --- |
-| Base triangles | 4150–4400 | 4272 / 4272 / 4272 |
+| Base triangles | 4000–5800 | 4872 / 4872 / 4872 |
 | LOD1 ratio | 0.32–0.62 of base | 0.5000 / 0.5000 / 0.5000 |
-| LOD2 ratio | 0.10–0.35 of base | 0.2196 / 0.2196 / 0.2196 |
-| Materials | exactly 3 distinct, ≥24 metal, ≥12 rope | 3 slots, 222 metal, 72 rope |
+| LOD2 ratio | 0.10–0.35 of base | 0.2196 / 0.2196 / 0.2188 |
+| Materials | exactly 3 distinct; ≥350 wood, ≥180 metal, ≥40 rope | 3 slots; 1424 / 1020 / 208 |
 | UVs | in `0..1`, AABB overlap ≤ 1e-5 | in range, overlap 0 |
-| Outer AABB | (0.402, 0.345, 0.544) m ± 0.01 | (0.4020, 0.3449, 0.5439), zmin 0 |
-| Collider tris | ≤ 420 | 390 |
-| Export | written, size > 0 | 330476 / 330476 / 330464 bytes |
+| Outer AABB | (0.383, 0.346, 0.527) m ± 0.015 | (0.3832, 0.3462, 0.5271), zmin 0 |
+| Collider tris | ≤ 420 | 302 |
+| Export | written, size > 0 | 378296 / 378296 / 378276 bytes |
+
+Base triangles rose from **4272 to 4872** in the quality pass: overlapping
+identical staves, circular hoops, and a 12-box bail became 16 jittered
+staves, chord-seated hoops, a polygonal croze floor, and a round bail
+through the ear rings.
 
 DECIMATE COLLAPSE triangle counts are **not** identical across series —
-the gate is a ratio band, not an exact count. Bake pixels are stochastic;
-the gate is `has_data` plus operator `FINISHED`, not byte-identity.
-Construction uses no RNG. Export byte counts differ by 12 B on 5.2.1
-(glTF serializer), not a gated axis.
+5.2.1 is 4 tris leaner on LOD2. The gate is a ratio band, not an exact
+count. Bake pixels are stochastic; the gate is `has_data` plus operator
+`FINISHED`, not byte-identity. Stave-width jitter uses fixed seed 17.
+Export byte counts differ by 20 B on 5.2.1 (glTF serializer), not a
+gated axis.
+
+### Hygiene
+
+Recomputed from the generated mesh, not asserted about the script.
+
+| Axis | Declared | Measured (all three) |
+| --- | --- | --- |
+| Non-manifold edges | 0 | 0 |
+| Loose verts / edges | 0 / 0 | 0 / 0 |
+| Doubles merged at 1e-5 | 0 | 0 |
+| Zero-area faces | 0 | 0 |
+| N-gons | 0 | 0 |
+| Coplanar disjoint face pairs | 0 | 0 |
+| Grounded: `zmin` | within 1e-4 of 0 | 0.0000 |
+| Named supports: 16 staves | each `zmin` ≤ 0.001 | 16, stave_z 0.00000 |
+| Body plan | 0.335 m dia × 0.360 m high ± 0.04 | 0.3349 × 0.3600 |
 
-`--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.
+### Joint fit and seat
+
+| Axis | Declared | Measured (all three) |
+| --- | --- | --- |
+| Bail-ear BVH gap | ≤ 0.006 m | 0.00125 |
+| Floor-croze rim BVH gap | ≤ 0.008 m | 0.00458 |
+| Hoop bite (host r − inner hoop r) | 0.0010–0.007 m | 0.00250 |
+
+### 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-staves` | named stave supports at Z=0 | 16 |
+| `--float-handle` | bail-ear gap | 17 |
+| `--float-bottom` | floor-croze gap | 17 |
+| `--round-band` | hoop bite band | 18 |
 
 ## Run
 
 ```bash
 blender --background --python wooden_bucket.py --
 blender --background --python wooden_bucket.py -- --skip-decimate
+blender --background --python wooden_bucket.py -- --stray-vert
+blender --background --python wooden_bucket.py -- --lift-z
+blender --background --python wooden_bucket.py -- --short-staves
+blender --background --python wooden_bucket.py -- --float-handle
+blender --background --python wooden_bucket.py -- --float-bottom
+blender --background --python wooden_bucket.py -- --round-band
 blender --background --python wooden_bucket.py -- --output bucket.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 +119,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 ≠ 3 distinct slots, or metal/rope faces missing |
+| 5 | Material count ≠ 3 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 +129,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 stave floats |
+| 17 | Joint fit: bail-ear gap or floor-croze gap |
+| 18 | Seat: hoop bite band (`--round-band`) |
+| 19 | Body diameter or height off the stated real-world size |
diff --git a/showcase/wooden-bucket/preview.webp b/showcase/wooden-bucket/preview.webp
index 289a57b..24570e8 100644
Binary files a/showcase/wooden-bucket/preview.webp and b/showcase/wooden-bucket/preview.webp differ
diff --git a/showcase/wooden-bucket/wooden_bucket.py b/showcase/wooden-bucket/wooden_bucket.py
index 15bc595..a4bbb89 100644
--- a/showcase/wooden-bucket/wooden_bucket.py
+++ b/showcase/wooden-bucket/wooden_bucket.py
@@ -1,14 +1,25 @@
 """Game-ready wooden bucket — a showcase piece, not an example.
 
-Asserts budget conformance of a procedural coopered bucket after composing
-shipped pipeline pieces: bmesh construction, UVs, three materials,
-high-to-low normal bake, LOD chain, convex collider, Unity glTF export.
+Asserts budget conformance of a procedural coopered bucket (tight staves
+with seeded width jitter, a bottom seated in a croze, iron hoops lofted
+on the stave faces, ear rings, a round rope bail through the rings)
+after composing shipped pipeline pieces: bmesh construction, UVs, three
+materials, high-to-low normal bake, LOD chain, convex collider, Unity
+glTF export.
 
-Budgets are declared below and recomputed from the generated result.
-They are not API-contract witnesses. ``--skip-decimate`` skips the LOD
-DECIMATE stage so the LOD-ratio budget fails.
+The old piece overlapped 14 identical staves into a 14-gon, wrapped them
+in capped-cylinder hoops that floated off the flats, and lofted the bail
+from 12 boxes that never entered the ear rings.
 
-No RNG. Construction is closed-form. DECIMATE COLLAPSE triangle counts
+Budgets are declared below and recomputed from the generated result.
+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-staves`` named stave
+supports, ``--float-handle`` bail-ear joint-fit, ``--float-bottom``
+floor-croze joint-fit, ``--round-band`` hoop seat (hoop generated on a
+circle instead of the stave chords).
+
+Fixed seed 17 for stave-width jitter. DECIMATE COLLAPSE triangle counts
 are not byte-identical across Blender versions — the LOD gate is a
 ratio band, not an exact count.
 
@@ -19,6 +30,7 @@
 import argparse
 import math
 import os
+import random
 import sys
 import tempfile
 import traceback
@@ -26,10 +38,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,26 +47,51 @@
 sys.dont_write_bytecode = True
 import gallery_framing  # noqa: E402
 
+# Pail scale: 36 cm bowl, 33 cm rim.
 HEIGHT = 0.36
 R_BOT = 0.125
 R_TOP = 0.168
-N_STAVES = 14
-STAVE_THICK = 0.022
-N_RINGS = 4
-# Negative gap = overlapping staves so the hull is sealed.
-STAVE_GAP = -0.08
-HOOP_ZS = (0.055, 0.155, 0.305)
-HOOP_H = 0.026
-HOOP_PAD = 0.011
-BOTTOM_T = 0.024
-BAIL_R = 0.012
-BAIL_SEGS = 12
-BBOX_TOL = 0.01
-# Fitted after locking geometry. Recomputed from bound_box.
-OUTER_SIZE = (0.402, 0.345, 0.544)
-
-BASE_TRIS_MIN = 4150
-BASE_TRIS_MAX = 4400
+BULGE = 0.012
+N_STAVES = 16
+STAVE_THICK = 0.018
+N_RINGS = 6
+STAVE_SEED = 17
+STAVE_JITTER = 0.08
+GAP_M = 0.0007
+HOOP_ZS = (0.055, 0.155, 0.300)
+HOOP_H = 0.022
+HOOP_PROUD = 0.006
+HOOP_BITE = 0.0025
+HOOP_CHAMFER = 0.0025
+HOOP_BITE_MIN = 0.0010
+HOOP_BITE_MAX = 0.007
+BOTTOM_T = 0.022
+CHIME = 0.008
+CROZE_BITE = 0.0025
+FLOOR_GAP_MAX = 0.008
+BAIL_R = 0.008
+BAIL_SEGS = 24
+BAIL_PIPE = 8
+EAR_Z = HEIGHT - 0.016
+RING_MAJOR = 0.013
+RING_MINOR = 0.0035
+BAIL_GAP_MAX = 0.006
+STAVE_ZMIN_MAX = 0.001
+SHORT_STAVES_LIFT = 0.040
+LIFT_Z = 0.05
+AREA_EPS = 1e-10
+DOUBLES_EPS = 1e-5
+ZMIN_EPS = 1e-4
+ZFIGHT_EPS = 1e-4
+ZFIGHT_COS = 0.998
+BODY_TOL = 0.04
+BODY_DIA = 0.335
+BODY_H = 0.360
+BBOX_TOL = 0.015
+OUTER_SIZE = (0.383, 0.346, 0.527)
+
+BASE_TRIS_MIN = 4000
+BASE_TRIS_MAX = 5800
 LOD1_RATIO_MIN = 0.32
 LOD1_RATIO_MAX = 0.62
 LOD2_RATIO_MIN = 0.10
@@ -64,13 +99,15 @@
 LOD1_TARGET = 0.50
 LOD2_TARGET = 0.22
 MATERIAL_COUNT = 3
+WOOD_FACES_MIN = 350
+METAL_FACES_MIN = 180
+ROPE_FACES_MIN = 40
 UV_EPS = 1e-4
 UV_OVERLAP_MAX = 1e-5
 COLLIDER_TRIS_MAX = 420
 BAKE_RES = 256
 CAGE_EXTRUSION = 0.06
-METAL_FACES_MIN = 24
-ROPE_FACES_MIN = 12
+STAVE_COUNT = N_STAVES
 
 WOOD_IDX = 0
 METAL_IDX = 1
@@ -92,7 +129,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()
@@ -105,69 +141,110 @@ def evaluated_triangle_count(obj):
 
 def radius_at(z):
     t = max(0.0, min(1.0, z / HEIGHT))
-    return R_BOT + (R_TOP - R_BOT) * t
-
-
-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
-    return verts
-
-
-def add_oriented_box(bm, a, b, scale_xy, mat_idx):
-    a = Vector(a)
-    b = Vector(b)
-    delta = b - a
-    length = delta.length
-    if length < 1e-8:
-        return []
-    quat = Vector((0.0, 0.0, 1.0)).rotation_difference(delta.normalized())
-    eul = quat.to_euler("XYZ")
-    return add_box(
-        bm,
-        ((a + b) * 0.5),
-        (scale_xy[0], scale_xy[1], length),
-        mat_idx,
-        euler=(eul.x, eul.y, eul.z),
-    )
-
-
-def add_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,
-    )
-    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
+    return R_BOT + (R_TOP - R_BOT) * t + BULGE * math.sin(math.pi * t)
+
+
+def stave_spans(n, gap_ang, jitter, seed):
+    rng = random.Random(seed)
+    weights = [1.0 + rng.uniform(-jitter, jitter) for _ in range(n)]
+    total = sum(weights)
+    usable = 2.0 * math.pi - n * gap_ang
+    spans = []
+    a = 0.0
+    for w in weights:
+        width = usable * (w / total)
+        spans.append((a, a + width))
+        a += width + gap_ang
+    return spans
+
+
+def host_outer_r(u, z, spans, round_band):
+    r = radius_at(z)
+    if round_band:
+        return r
+    u = u % (2.0 * math.pi)
+    for a0, a1 in spans:
+        if a0 - 1e-9 <= u <= a1 + 1e-9:
+            mid = 0.5 * (a0 + a1)
+            half = 0.5 * (a1 - a0)
+            den = math.cos(u - mid)
+            if abs(den) < 1e-4:
+                return r * math.cos(half)
+            return r * math.cos(half) / den
+    return r
+
+
+def loft_cyclic(bm, sections, mat_idx):
+    vert_rings = [[bm.verts.new(p) for p in s] for s in sections]
+    m = len(vert_rings)
+    n = len(vert_rings[0])
+    faces = []
+    for k in range(m):
+        a = vert_rings[k]
+        b = vert_rings[(k + 1) % m]
+        for i in range(n):
+            j = (i + 1) % n
+            face = bm.faces.new((a[i], a[j], b[j], b[i]))
+            face.material_index = mat_idx
+            faces.append(face)
+    return [v for ring in vert_rings for v in ring], faces
 
 
-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 loft_rings(bm, rings, mat_idx, cap_start=True, cap_end=True):
+    n = len(rings[0])
+    for k in range(len(rings) - 1):
+        a, b = rings[k], rings[k + 1]
+        for i in range(n):
+            j = (i + 1) % n
+            face = bm.faces.new((a[i], a[j], b[j], b[i]))
+            face.material_index = mat_idx
+    if cap_start:
+        fan_cap(bm, rings[0], mat_idx, flip=True)
+    if cap_end:
+        fan_cap(bm, rings[-1], mat_idx, flip=False)
+
+
+def fan_cap(bm, ring, mat_idx, flip=False):
+    center = Vector((0.0, 0.0, 0.0))
+    for v in ring:
+        center += v.co
+    center /= len(ring)
+    hub = bm.verts.new(center)
+    n = len(ring)
+    for i in range(n):
+        vs = (hub, ring[i], ring[(i + 1) % n])
+        if flip:
+            vs = (hub, vs[2], vs[1])
+        face = bm.faces.new(vs)
+        face.material_index = mat_idx
+    return hub
+
+
+def croze_xy(spans, z, bite, shrink=0.0):
+    pts = []
+    for a0, a1 in spans:
+        for u in (a0, 0.5 * (a0 + a1), a1):
+            r = host_outer_r(u, z, spans, False) - STAVE_THICK + bite - shrink
+            pts.append((r * math.cos(u), r * math.sin(u)))
+    return pts
+
+
+def add_polygon_disk(bm, z0, z1, xy_ring, mat_idx):
+    rings = []
+    for z in (z0, z1):
+        ring = [bm.verts.new((x, y, z)) for x, y in xy_ring]
+        rings.append(ring)
+    a, b = rings
+    n = len(xy_ring)
+    for i in range(n):
+        j = (i + 1) % n
+        face = bm.faces.new((a[i], a[j], b[j], b[i]))
+        face.material_index = mat_idx
+    fan_cap(bm, a, mat_idx, flip=True)
+    fan_cap(bm, b, mat_idx, flip=False)
 
 
-def add_rim(bm, loc, major, minor, mat_idx, euler=(0.0, 0.0, 0.0)):
-    n_major = 12
-    n_minor = 6
+def add_torus(bm, loc, major, minor, n_major, n_minor, mat_idx, euler=(0.0, 0.0, 0.0)):
     rings = []
     for i in range(n_major):
         u = i * (2.0 * math.pi / n_major)
@@ -179,6 +256,7 @@ def add_rim(bm, loc, major, minor, mat_idx, euler=(0.0, 0.0, 0.0)):
             z = minor * math.sin(v)
             ring.append(bm.verts.new((x, y, z)))
         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):
@@ -187,7 +265,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:
@@ -195,6 +272,192 @@ def add_rim(bm, loc, major, minor, mat_idx, euler=(0.0, 0.0, 0.0)):
     return verts
 
 
+def add_pipe_curve(bm, points, radius, segs, mat_idx):
+    rings = []
+    n = len(points)
+    for i, p in enumerate(points):
+        p = Vector(p)
+        if i < n - 1:
+            tangent = (Vector(points[i + 1]) - p).normalized()
+        else:
+            tangent = (p - Vector(points[i - 1])).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()
+        ring = []
+        for k in range(segs):
+            a = 2.0 * math.pi * k / segs
+            ring.append(
+                bm.verts.new(
+                    p + side * (radius * math.cos(a)) + up * (radius * math.sin(a))
+                )
+            )
+        rings.append(ring)
+    loft_rings(bm, rings, mat_idx, cap_start=True, cap_end=True)
+
+
+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
+    return verts
+
+
+def build_hoops(bm, spans, round_band):
+    for z_mid in HOOP_ZS:
+        z0 = z_mid - HOOP_H * 0.5
+        z1 = z_mid + HOOP_H * 0.5
+        c = HOOP_CHAMFER
+        sections = []
+        samples = []
+        for a0, a1 in spans:
+            samples.append(a0)
+            samples.append(0.5 * (a0 + a1))
+            samples.append(a1)
+        for u in samples:
+            cu, su = math.cos(u), math.sin(u)
+            r0 = host_outer_r(u, z0, spans, round_band)
+            r1 = host_outer_r(u, z1, spans, round_band)
+            profile = (
+                (r0 - HOOP_BITE, z0),
+                (r0 + HOOP_PROUD - c, z0),
+                (r0 + HOOP_PROUD, z0 + c),
+                (r1 + HOOP_PROUD, z1 - c),
+                (r1 + HOOP_PROUD - c, z1),
+                (r1 - HOOP_BITE, z1),
+            )
+            sections.append([Vector((r * cu, r * su, z)) for r, z in profile])
+        loft_cyclic(bm, sections, METAL_IDX)
+
+
+def build_staves(bm, spans, z0, bevel_offset, bevel_segments):
+    zs = [HEIGHT * i / (N_RINGS - 1) for i in range(N_RINGS)]
+    stave_verts = []
+    for a0, a1 in spans:
+        outer = []
+        inner = []
+        for z in zs:
+            r = radius_at(z)
+            ov = (
+                bm.verts.new((r * math.cos(a0), r * math.sin(a0), z0 + z)),
+                bm.verts.new((r * math.cos(a1), r * math.sin(a1), z0 + z)),
+            )
+            ri = r - STAVE_THICK
+            iv = (
+                bm.verts.new((ri * math.cos(a0), ri * math.sin(a0), z0 + z)),
+                bm.verts.new((ri * math.cos(a1), ri * math.sin(a1), z0 + z)),
+            )
+            outer.append(ov)
+            inner.append(iv)
+            stave_verts.extend(ov)
+            stave_verts.extend(iv)
+        for k in range(N_RINGS - 1):
+            o0a, o0b = outer[k]
+            o1a, o1b = outer[k + 1]
+            i0a, i0b = inner[k]
+            i1a, i1b = inner[k + 1]
+            for vs in (
+                (o0a, o1a, o1b, o0b),
+                (i0b, i1b, i1a, i0a),
+                (o0a, i0a, i1a, o1a),
+                (o0b, o1b, i1b, i0b),
+            ):
+                face = bm.faces.new(vs)
+                face.material_index = WOOD_IDX
+        top = bm.faces.new((outer[-1][0], outer[-1][1], inner[-1][1], inner[-1][0]))
+        top.material_index = WOOD_IDX
+        bot = bm.faces.new((outer[0][1], outer[0][0], inner[0][0], inner[0][1]))
+        bot.material_index = WOOD_IDX
+    if bevel_offset > 0.0:
+        long_edges = []
+        seen = set()
+        for v in stave_verts:
+            for e in v.link_edges:
+                if e in seen:
+                    continue
+                seen.add(e)
+                a, b = e.verts
+                if abs(a.co.z - b.co.z) > 0.015:
+                    long_edges.append(e)
+        if long_edges:
+            bmesh.ops.bevel(
+                bm,
+                geom=long_edges,
+                offset=bevel_offset,
+                segments=bevel_segments,
+                profile=0.5,
+                affect="EDGES",
+                clamp_overlap=True,
+            )
+    return stave_verts
+
+
+def triangulate_ngons(bm):
+    faces = [f for f in bm.faces if len(f.verts) > 4]
+    if faces:
+        bmesh.ops.triangulate(bm, faces=faces)
+
+
+def add_ears_and_bail(bm, spans, float_handle):
+    """Ear plates + flat rings (hole along Z) and a round bail through them.
+
+    Ring centres sit on the stave outer at EAR_Z. The bail is a semicircle
+    in XZ whose ends are vertical, so they pass through the rings. A
+    smaller semicircle is the falsifier: the bar sits on the ring.
+    """
+    u_l = 0.5 * (spans[0][0] + spans[0][1])
+    u_r = 0.5 * (spans[N_STAVES // 2][0] + spans[N_STAVES // 2][1])
+    r_l = host_outer_r(u_l, EAR_Z, spans, False)
+    r_r = host_outer_r(u_r, EAR_Z, spans, False)
+    plate_t = 0.007
+    plate_h = 0.036
+    plate_w = 0.028
+    plate_z = HEIGHT - plate_h * 0.5 - 0.006
+    x_l = -(r_l + plate_t * 0.5)
+    x_r = r_r + plate_t * 0.5
+    ring_x_l = -(r_l + plate_t + RING_MAJOR * 0.25)
+    ring_x_r = r_r + plate_t + RING_MAJOR * 0.25
+    for x in (x_l, x_r):
+        add_box(
+            bm,
+            (x, 0.0, plate_z),
+            (plate_t, plate_w, plate_h),
+            METAL_IDX,
+        )
+    for x in (ring_x_l, ring_x_r):
+        add_torus(
+            bm,
+            (x, 0.0, EAR_Z),
+            RING_MAJOR,
+            RING_MINOR,
+            12,
+            6,
+            METAL_IDX,
+            euler=(0.0, 0.0, 0.0),
+        )
+    rx = 0.5 * (abs(ring_x_l) + abs(ring_x_r))
+    if float_handle:
+        rx *= 0.72
+        z0 = EAR_Z + 0.035
+    else:
+        z0 = EAR_Z
+    pts = []
+    for i in range(BAIL_SEGS + 1):
+        t = math.pi * i / BAIL_SEGS
+        pts.append((rx * math.cos(t), 0.0, z0 + rx * math.sin(t)))
+    add_pipe_curve(bm, pts, BAIL_R, BAIL_PIPE, ROPE_IDX)
+
+
 def pack_uvs(bm, margin=0.08):
     uv = bm.loops.layers.uv.new("UVMap")
     faces = list(bm.faces)
@@ -211,9 +474,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
@@ -238,122 +499,32 @@ def pack_uvs(bm, margin=0.08):
             )
 
 
-def build_bucket_mesh(name, bevel_offset, bevel_segments):
+def build_bucket_mesh(
+    name,
+    bevel_offset,
+    bevel_segments,
+    short_staves=False,
+    float_handle=False,
+    round_band=False,
+    float_bottom=False,
+):
     bm = bmesh.new()
-    stave_verts = []
-    hoop_faces = set()
-    rope_faces = set()
+    gap_ang = GAP_M / max(R_TOP, 0.1)
+    spans = stave_spans(N_STAVES, gap_ang, STAVE_JITTER, STAVE_SEED)
+    z0 = SHORT_STAVES_LIFT if short_staves else 0.0
     try:
-        zs = [HEIGHT * i / (N_RINGS - 1) for i in range(N_RINGS)]
-        for i in range(N_STAVES):
-            a0 = 2.0 * math.pi * i / N_STAVES
-            a1 = 2.0 * math.pi * (i + 1.0 - STAVE_GAP) / N_STAVES
-            outer = []
-            inner = []
-            for z in zs:
-                r = radius_at(z)
-                ov = (
-                    bm.verts.new((r * math.cos(a0), r * math.sin(a0), z)),
-                    bm.verts.new((r * math.cos(a1), r * math.sin(a1), z)),
-                )
-                ri = r - STAVE_THICK
-                iv = (
-                    bm.verts.new((ri * math.cos(a0), ri * math.sin(a0), z)),
-                    bm.verts.new((ri * math.cos(a1), ri * math.sin(a1), z)),
-                )
-                outer.append(ov)
-                inner.append(iv)
-                stave_verts.extend(ov)
-                stave_verts.extend(iv)
-            for k in range(N_RINGS - 1):
-                o0a, o0b = outer[k]
-                o1a, o1b = outer[k + 1]
-                i0a, i0b = inner[k]
-                i1a, i1b = inner[k + 1]
-                for vs in (
-                    (o0a, o1a, o1b, o0b),
-                    (i0b, i1b, i1a, i0a),
-                    (o0a, i0a, i1a, o1a),
-                    (o0b, o1b, i1b, i0b),
-                ):
-                    face = bm.faces.new(vs)
-                    face.material_index = WOOD_IDX
-            # Rim only — no top lid. Interior stays open.
-            top = bm.faces.new((outer[-1][0], outer[-1][1], inner[-1][1], inner[-1][0]))
-            top.material_index = WOOD_IDX
-            bot = bm.faces.new((outer[0][1], outer[0][0], inner[0][0], inner[0][1]))
-            bot.material_index = WOOD_IDX
-
-        if bevel_offset > 0.0:
-            edges = list({e for v in stave_verts for e in v.link_edges})
-            bmesh.ops.bevel(
-                bm,
-                geom=edges,
-                offset=bevel_offset,
-                segments=bevel_segments,
-                profile=0.5,
-                affect="EDGES",
-                clamp_overlap=True,
-            )
-
-        # Bottom seated inside the hull so the basin actually holds.
-        add_cylinder(
-            bm,
-            (0.0, 0.0, BOTTOM_T / 2.0),
-            R_BOT - STAVE_THICK * 0.35,
-            BOTTOM_T,
-            16,
+        build_staves(bm, spans, z0, bevel_offset, bevel_segments)
+        bot_z0 = CHIME
+        bot_z1 = CHIME + BOTTOM_T
+        shrink = 0.022 if float_bottom else 0.0
+        add_polygon_disk(
+            bm, bot_z0, bot_z1,
+            croze_xy(spans, 0.5 * (bot_z0 + bot_z1), CROZE_BITE, shrink),
             WOOD_IDX,
         )
-
-        for z in HOOP_ZS:
-            before = set(bm.faces)
-            add_cylinder(
-                bm,
-                (0.0, 0.0, z),
-                radius_at(z) + HOOP_PAD,
-                HOOP_H,
-                20,
-                METAL_IDX,
-            )
-            hoop_faces.update(set(bm.faces) - before)
-
-        ear_x = R_TOP + 0.006
-        ear_z = HEIGHT - 0.018
-        for sign in (-1.0, 1.0):
-            before = set(bm.faces)
-            add_box(
-                bm,
-                (sign * ear_x, 0.0, ear_z),
-                (0.028, 0.036, 0.048),
-                METAL_IDX,
-            )
-            add_rim(
-                bm,
-                (sign * (ear_x + 0.006), 0.0, ear_z + 0.012),
-                0.016,
-                0.005,
-                METAL_IDX,
-                euler=(math.radians(90.0), 0.0, 0.0),
-            )
-            hoop_faces.update(set(bm.faces) - before)
-
-        bail_major = ear_x + 0.004
-        bail_pts = []
-        for i in range(BAIL_SEGS + 1):
-            t = math.pi * i / BAIL_SEGS
-            bail_pts.append(
-                (
-                    bail_major * math.cos(t),
-                    0.0,
-                    ear_z + 0.012 + bail_major * math.sin(t),
-                )
-            )
-        before = set(bm.faces)
-        for a, b in zip(bail_pts, bail_pts[1:]):
-            add_oriented_box(bm, a, b, (BAIL_R * 2.0, BAIL_R * 2.0), ROPE_IDX)
-        rope_faces.update(set(bm.faces) - before)
-
+        build_hoops(bm, spans, round_band)
+        add_ears_and_bail(bm, spans, float_handle)
+        triangulate_ngons(bm)
         pack_uvs(bm)
         bmesh.ops.recalc_face_normals(bm, faces=list(bm.faces))
         for face in bm.faces:
@@ -363,12 +534,6 @@ def build_bucket_mesh(name, bevel_offset, bevel_segments):
             if edge.is_manifold and len(edge.link_faces) == 2:
                 if edge.calc_face_angle() > math.radians(35.0):
                     edge.smooth = False
-        for f in hoop_faces:
-            if f.is_valid:
-                f.material_index = METAL_IDX
-        for f in rope_faces:
-            if f.is_valid:
-                f.material_index = ROPE_IDX
         me = bpy.data.meshes.new(name)
         bm.to_mesh(me)
         me.update()
@@ -379,32 +544,44 @@ def build_bucket_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, rope):
     mats = obj.data.materials
-    if len(mats) == 0:
-        mats.append(wood)
-        mats.append(metal)
-        mats.append(rope)
-        return
-    mats[0] = wood
-    if len(mats) == 1:
-        mats.append(metal)
-    else:
-        mats[1] = metal
-    if len(mats) == 2:
-        mats.append(rope)
-    else:
-        mats[2] = rope
+    wanted = (wood, metal, rope)
+    for i, mat in enumerate(wanted):
+        if i < len(mats):
+            mats[i] = mat
+        else:
+            mats.append(mat)
 
 
 def world_bbox(obj):
@@ -415,6 +592,17 @@ def world_bbox(obj):
     return (min(xs), min(ys), min(zs), max(xs), max(ys), max(zs))
 
 
+def face_area(me, poly):
+    verts = [me.vertices[i].co for i in poly.vertices]
+    if len(verts) < 3:
+        return 0.0
+    acc = Vector((0.0, 0.0, 0.0))
+    origin = verts[0]
+    for a, b in zip(verts[1:], verts[2:]):
+        acc += (a - origin).cross(b - origin)
+    return 0.5 * acc.length
+
+
 def uv_stats(mesh):
     uv = mesh.uv_layers.active
     if uv is None:
@@ -440,6 +628,239 @@ def uv_stats(mesh):
     return min(us), min(vs), max(us), max(vs), overlap, len(aabbs)
 
 
+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)
+    staves = []
+    for g in groups:
+        if mat_of(me, g) != WOOD_IDX:
+            continue
+        a = shell_aabb(me, g)
+        dz = a[5] - a[2]
+        if dz > 0.20:
+            staves.append(a)
+    stave_z = min((a[2] for a in staves), default=99.0)
+    return {"staves": len(staves), "stave_z": stave_z}
+
+
+def hoop_seat(me, spans):
+    groups = shells(me)
+    bites = []
+    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.06 or max(dx, dy) < 0.20:
+            continue
+        rs = [math.hypot(me.vertices[i].co.x, me.vertices[i].co.y) for i in g]
+        for i, r in zip(g, rs):
+            p = me.vertices[i].co
+            u = math.atan2(p.y, p.x)
+            host = host_outer_r(u, p.z, spans, False)
+            if r > host + 0.0005:
+                continue
+            bites.append(host - r)
+    if not bites:
+        return 0.05, 0.05
+    return min(bites), max(bites)
+
+
+def floor_gap(me):
+    groups = shells(me)
+    floors, staves = [], []
+    for g in groups:
+        if mat_of(me, g) != WOOD_IDX:
+            continue
+        a = shell_aabb(me, g)
+        dz = a[5] - a[2]
+        r = 0.25 * ((a[3] - a[0]) + (a[4] - a[1]))
+        if dz < 0.05 and r > 0.08:
+            floors.append(g)
+        elif dz > 0.20:
+            staves.append(g)
+    if not floors or not staves:
+        return 99.0
+    bm_s = bmesh.new()
+    try:
+        bm_s.from_mesh(me)
+        keep = set()
+        for g in staves:
+            keep.update(g)
+        drop = [f for f in bm_s.faces if not all(v.index in keep for v in f.verts)]
+        if drop:
+            bmesh.ops.delete(bm_s, geom=drop, context="FACES")
+        if not bm_s.faces:
+            return 99.0
+        tree = BVHTree.FromBMesh(bm_s)
+        worst = 0.0
+        for g in floors:
+            rmax = max(math.hypot(me.vertices[i].co.x, me.vertices[i].co.y) for i in g)
+            for i in g:
+                p = me.vertices[i].co
+                if math.hypot(p.x, p.y) < 0.90 * rmax:
+                    continue
+                loc, _n, _i, dist = tree.find_nearest(p)
+                if loc is None:
+                    continue
+                worst = max(worst, dist)
+        return worst
+    finally:
+        bm_s.free()
+
+
+def bail_join(me):
+    groups = shells(me)
+    rings, bails = [], []
+    for g in groups:
+        a = shell_aabb(me, g)
+        dx, dy, dz = a[3] - a[0], a[4] - a[1], a[5] - a[2]
+        mat = mat_of(me, g)
+        if mat == METAL_IDX and max(dx, dy, dz) < 0.08 and a[2] > 0.25:
+            rings.append(g)
+        elif mat == ROPE_IDX:
+            bails.append(g)
+    if not rings or not bails:
+        return 99.0
+    bm_b = bmesh.new()
+    try:
+        bm_b.from_mesh(me)
+        keep = set()
+        for g in bails:
+            keep.update(g)
+        drop = [f for f in bm_b.faces if not all(v.index in keep for v in f.verts)]
+        if drop:
+            bmesh.ops.delete(bm_b, geom=drop, context="FACES")
+        if not bm_b.faces:
+            return 99.0
+        tree = BVHTree.FromBMesh(bm_b)
+        best = 99.0
+        for g in rings:
+            for i in g:
+                p = me.vertices[i].co
+                loc, _n, _idx, dist = tree.find_nearest(p)
+                if loc is None:
+                    continue
+                best = min(best, dist)
+        return best
+    finally:
+        bm_b.free()
+
+
+def body_plan(me):
+    groups = shells(me)
+    xs, ys, z0s, z1s = [], [], [], []
+    for g in groups:
+        if mat_of(me, g) != WOOD_IDX:
+            continue
+        a = shell_aabb(me, g)
+        if a[5] - a[2] < 0.20:
+            continue
+        xs.extend((a[0], a[3]))
+        ys.extend((a[1], a[4]))
+        z0s.append(a[2])
+        z1s.append(a[5])
+    if not xs:
+        return 0.0, 0.0
+    dia = 0.5 * ((max(xs) - min(xs)) + (max(ys) - min(ys)))
+    return dia, max(z1s) - min(z0s)
+
+
+def add_stray_vert(me):
+    bm = bmesh.new()
+    try:
+        bm.from_mesh(me)
+        bm.verts.new((0.0, 0.0, HEIGHT * 0.5))
+        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)
@@ -453,7 +874,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:
@@ -465,6 +885,14 @@ def convex_hull_collider(obj, name):
             bmesh.ops.delete(bm, geom=interior, context="VERTS")
         if unused:
             bmesh.ops.delete(bm, geom=unused, context="VERTS")
+        bmesh.ops.dissolve_limit(
+            bm,
+            angle_limit=math.radians(10.0),
+            verts=list(bm.verts),
+            edges=list(bm.edges),
+            delimit={"NORMAL"},
+        )
+        bmesh.ops.triangulate(bm, faces=list(bm.faces))
         bm.to_mesh(mesh)
         mesh.update()
     finally:
@@ -476,7 +904,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("BucketNrm", size, size, alpha=True, float_buffer=False)
@@ -491,7 +918,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"
@@ -516,7 +942,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:
@@ -532,19 +957,50 @@ def export_unity(path, objects):
     )
 
 
-def check(skip_decimate):
+def check(
+    skip_decimate,
+    lift_z=False,
+    stray_vert=False,
+    short_staves=False,
+    float_handle=False,
+    round_band=False,
+    float_bottom=False,
+):
     bpy.ops.wm.read_factory_settings(use_empty=True)
-    low = build_bucket_mesh("BucketLow", bevel_offset=0.003, bevel_segments=2)
-    high = build_bucket_mesh("BucketHigh", bevel_offset=0.003, bevel_segments=4)
-    wood = principled("BucketWood", (0.46, 0.24, 0.09, 1.0), 0.0, 0.52)
-    metal = principled("BucketMetal", (0.58, 0.56, 0.52, 1.0), 1.0, 0.24)
-    rope = principled("BucketRope", (0.42, 0.32, 0.18, 1.0), 0.0, 0.78)
+    flags = dict(
+        short_staves=short_staves,
+        float_handle=float_handle,
+        round_band=round_band,
+        float_bottom=float_bottom,
+    )
+    low = build_bucket_mesh("BucketLow", 0.003, 2, **flags)
+    high = build_bucket_mesh("BucketHigh", 0.003, 4, **flags)
+    wood = principled(
+        "BucketWood", (0.46, 0.24, 0.09, 1.0), 0.0, 0.52,
+        noise_scale=7.0, wear=(0.28, 0.14, 0.05, 1.0),
+    )
+    metal = principled(
+        "BucketHoop", (0.55, 0.53, 0.50, 1.0), 1.0, 0.28,
+        noise_scale=5.0, wear=(0.35, 0.32, 0.28, 1.0),
+    )
+    rope = principled(
+        "BucketRope", (0.42, 0.32, 0.18, 1.0), 0.0, 0.72,
+        noise_scale=9.0, wear=(0.30, 0.22, 0.12, 1.0),
+    )
     assign_slots(low, wood, metal, rope)
     assign_slots(high, wood, metal, rope)
+    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("bucket mesh did not build", 3), None, None, None, None, None
 
+    spans = stave_spans(N_STAVES, GAP_M / max(R_TOP, 0.1), STAVE_JITTER, STAVE_SEED)
     base_tris = triangle_count(low.data)
     mats = [s for s in low.data.materials if s is not None]
     nmat = len(mats)
@@ -558,6 +1014,23 @@ def check(skip_decimate):
     size_x = bb[3] - bb[0]
     size_y = bb[4] - bb[1]
     size_z = bb[5] - bb[2]
+    hyg = hygiene_audit(low.data)
+    zf = zfight_pairs(low.data)
+    sup = support_audit(low.data)
+    bite_min, bite_max = hoop_seat(low.data, spans)
+    bjoin = bail_join(low.data)
+    fgap = floor_gap(low.data)
+    dia, ht = body_plan(low.data)
+    print(
+        f"measured hygiene loose_v={hyg['loose_v']} loose_e={hyg['loose_e']} "
+        f"nonman={hyg['nonman']} zero_area={hyg['zero_area']} "
+        f"doubles={hyg['doubles']} ngons={hyg['ngons']} zfight={zf}"
+    )
+    print(
+        f"measured staves={sup['staves']} stave_z={sup['stave_z']:.5f} "
+        f"hoop_bite={bite_min:.5f}..{bite_max:.5f} bail_join={bjoin:.5f} "
+        f"floor_gap={fgap:.5f} body={dia:.4f}x{ht:.4f}"
+    )
 
     img, tex = setup_bake_image(low, wood)
     if img is None:
@@ -572,7 +1045,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_bucket_mesh("BucketColSrc", bevel_offset=0.0, bevel_segments=1)
+    collider_src = build_bucket_mesh("BucketColSrc", 0.0, 1)
     collider = convex_hull_collider(collider_src, "BucketCollider")
     bpy.data.objects.remove(collider_src, do_unlink=True)
     col_tris = triangle_count(collider.data)
@@ -586,9 +1059,7 @@ 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}"
-    )
+    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}"
@@ -616,6 +1087,11 @@ def check(skip_decimate):
             f"material slots {nmat} distinct {distinct_mats} != {MATERIAL_COUNT}",
             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 idx_counts.get(METAL_IDX, 0) < METAL_FACES_MIN:
         return fail(
             f"metal faces {idx_counts.get(METAL_IDX, 0)} < {METAL_FACES_MIN}",
@@ -669,6 +1145,58 @@ 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} "
+            "(--stray-vert is the designed fail)",
+            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["staves"] != STAVE_COUNT or sup["stave_z"] > STAVE_ZMIN_MAX:
+        return fail(
+            f"named staves {sup['staves']} z={sup['stave_z']:.5f} "
+            "(--short-staves is the designed fail)",
+            16,
+        ), None, None, None, None, None
+    if bjoin > BAIL_GAP_MAX:
+        return fail(
+            f"bail-ear gap {bjoin:.5f} > {BAIL_GAP_MAX} "
+            "(--float-handle is the designed fail)",
+            17,
+        ), None, None, None, None, None
+    if fgap > FLOOR_GAP_MAX:
+        return fail(
+            f"floor-croze gap {fgap:.5f} > {FLOOR_GAP_MAX} "
+            "(--float-bottom is the designed fail)",
+            17,
+        ), None, None, None, None, None
+    if bite_min < HOOP_BITE_MIN or bite_max > HOOP_BITE_MAX:
+        return fail(
+            f"hoop bite {bite_min:.5f}..{bite_max:.5f} "
+            f"outside [{HOOP_BITE_MIN}, {HOOP_BITE_MAX}] "
+            "(--round-band is the designed fail)",
+            18,
+        ), None, None, None, None, None
+    if abs(dia - BODY_DIA) > BODY_TOL or abs(ht - BODY_H) > BODY_TOL:
+        return fail(
+            f"body plan {dia:.4f}x{ht:.4f} off {BODY_DIA}x{BODY_H}",
+            19,
+        ), None, None, None, None, None
     return 0, low, high, wood, tex, collider
 
 
@@ -681,15 +1209,13 @@ def wire_normal(mat, tex):
     nt.links.new(nrm.outputs["Normal"], bsdf.inputs["Normal"])
 
 
-def render_still(low, wood, tex, path, engine):
+def render_still(low, wood, _tex, path, engine):
     scene = bpy.context.scene
-    wire_normal(wood, tex)
     for ob in list(scene.objects):
         if ob.type == "MESH" and ob != low:
             ob.hide_render = True
             ob.hide_viewport = True
 
-    # Three-quarter from above so the open basin and bottom read.
     low.rotation_euler.z = math.radians(-38.0)
     low.rotation_euler.x = math.radians(8.0)
 
@@ -737,10 +1263,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.05, -1.42, 1.12)
+    cam.location = (0.94, -1.28, 1.16)
     scene.collection.objects.link(cam)
     aim = bpy.data.objects.new("Aim", None)
-    aim.location = (0.0, 0.0, 0.30)
+    aim.location = (0.0, 0.0, 0.28)
     scene.collection.objects.link(aim)
     con = cam.constraints.new("TRACK_TO")
     con.target = aim
@@ -783,14 +1309,24 @@ def main():
     p = argparse.ArgumentParser()
     p.add_argument("--output", default=None)
     p.add_argument("--engine", default="eevee", choices=("eevee", "cycles"))
-    p.add_argument(
-        "--skip-decimate",
-        action="store_true",
-        help="falsification: skip the LOD DECIMATE stage",
-    )
+    p.add_argument("--skip-decimate", action="store_true")
+    p.add_argument("--stray-vert", action="store_true")
+    p.add_argument("--lift-z", action="store_true")
+    p.add_argument("--short-staves", action="store_true")
+    p.add_argument("--float-handle", action="store_true")
+    p.add_argument("--float-bottom", action="store_true")
+    p.add_argument("--round-band", 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_staves=args.short_staves,
+        float_handle=args.float_handle,
+        round_band=args.round_band,
+        float_bottom=args.float_bottom,
+    )
     if code:
         return code
     if args.output: