diff --git a/docs/gallery/assets/park-bench-hero.webp b/docs/gallery/assets/park-bench-hero.webp
index 9d4d4eb..3305f65 100644
Binary files a/docs/gallery/assets/park-bench-hero.webp and b/docs/gallery/assets/park-bench-hero.webp differ
diff --git a/docs/gallery/assets/terrain-scatter-hero.webp b/docs/gallery/assets/terrain-scatter-hero.webp
index a60c903..8325bc5 100644
Binary files a/docs/gallery/assets/terrain-scatter-hero.webp and b/docs/gallery/assets/terrain-scatter-hero.webp differ
diff --git a/docs/gallery/index.html b/docs/gallery/index.html
index 84c1f05..8d201e3 100644
--- a/docs/gallery/index.html
+++ b/docs/gallery/index.html
@@ -964,12 +964,12 @@ <h2><a href="treasure-chest/">treasure-chest</a></h2>
       </article>
       <article class="card" data-tags="mesh export showcase">
         <a class="card-media" href="terrain-scatter/" aria-label="terrain-scatter example detail page">
-          <img src="assets/terrain-scatter-hero.webp" alt="terrain-scatter — A Geometry Nodes hill tile with masonry scatter through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." loading="lazy" decoding="async" />
+          <img src="assets/terrain-scatter-hero.webp" alt="terrain-scatter — A Geometry Nodes hill tile with seated icosphere scatter through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API…" loading="lazy" decoding="async" />
         </a>
         <div class="card-body">
           <h2><a href="terrain-scatter/">terrain-scatter</a></h2>
-          <p class="teaches">A Geometry Nodes hill tile with masonry scatter 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: 1194 tris, two materials with 486 stone faces, UVs in 0..1 with zero AABB overlap, outer AABB 1.800×1.800×0.655 m, LOD ratios in band, convex collider 52 tris, non-empty glTF. --skip-decimate exits 9 on the LOD1 ratio budget.</p>
+          <p class="teaches">A Geometry Nodes hill tile with seated icosphere scatter 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: 1758 tris, two materials with 720 stone faces, UVs in 0..1 with zero AABB overlap, outer AABB 1.800×1.800×0.552 m, grounded zmin, 9 stones of ≥80 faces seated on sampled dirt Z (offset −35 mm, floor zmin 0.113 m), LOD ratios in band, convex collider 81 tris, hygiene zero, non-empty glTF. --skip-decimate exits 9; --stray-vert 15; --lift-z 16; --poke-rock 17; --float-rocks 18; --box-rocks 19.</p>
           <a class="card-link" href="terrain-scatter/">View example <span aria-hidden="true">&rarr;</span></a>
         </div>
       </article>
@@ -1008,12 +1008,12 @@ <h2><a href="cart/">cart</a></h2>
       </article>
       <article class="card" data-tags="mesh export showcase">
         <a class="card-media" href="park-bench/" aria-label="park-bench example detail page">
-          <img src="assets/park-bench-hero.webp" alt="park-bench — A procedural wrought-iron park bench through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." loading="lazy" decoding="async" />
+          <img src="assets/park-bench-hero.webp" alt="park-bench — A procedural wrought-iron park bench with tangent tube scroll feet through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than…" loading="lazy" decoding="async" />
         </a>
         <div class="card-body">
           <h2><a href="park-bench/">park-bench</a></h2>
-          <p class="teaches">A procedural wrought-iron park bench 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: 2100 tris, two materials with 510 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 1.080×0.566×0.853 m, LOD ratios in band (5.2 COLLAPSE more aggressive on LOD2), convex collider 106 tris, non-empty glTF. --skip-decimate exits 9 on the LOD1 ratio budget.</p>
+          <p class="teaches">A procedural wrought-iron park bench with tangent tube scroll feet 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: 2520 tris, two materials with 540 metal and 756 wood faces, UVs in 0..1 with zero AABB overlap, outer AABB 1.295×0.632×0.884 m, grounded zmin, 4 named toes, stretcher gap 1.2 mm, slat gap 0.3 mm, seat span 1.272 m, LOD ratios in band, convex collider 82 tris, hygiene zero, non-empty glTF. --skip-decimate exits 9; --stray-vert 15; --lift-z/--short-feet 16; --float-stretcher 17; --gap-slats 18; --narrow-seat 19.</p>
           <a class="card-link" href="park-bench/">View example <span aria-hidden="true">&rarr;</span></a>
         </div>
       </article>
diff --git a/docs/gallery/park-bench/index.html b/docs/gallery/park-bench/index.html
index a7246da..63c7040 100644
--- a/docs/gallery/park-bench/index.html
+++ b/docs/gallery/park-bench/index.html
@@ -4,18 +4,18 @@
   <meta charset="utf-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1" />
   <title>park-bench — Examples — Blender Developer Tools</title>
-  <meta name="description" content="A procedural wrought-iron park bench through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
+  <meta name="description" content="A procedural wrought-iron park bench with tangent tube scroll feet 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/park-bench/" />
   <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="park-bench — Examples — Blender Developer Tools" />
-  <meta property="og:description" content="A procedural wrought-iron park bench through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
+  <meta property="og:description" content="A procedural wrought-iron park bench with tangent tube scroll feet 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/park-bench/" />
   <meta property="og:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/park-bench-hero.webp" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="park-bench — Examples — Blender Developer Tools" />
-  <meta name="twitter:description" content="A procedural wrought-iron park bench through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
+  <meta name="twitter:description" content="A procedural wrought-iron park bench with tangent tube scroll feet 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/park-bench-hero.webp" />
   <style>
     /* fonts are deployed by the landing build (docs/fonts/) */
@@ -246,35 +246,52 @@
   </div>
   <header class="hero">
     <h1>park-bench</h1>
-    <p>A procedural wrought-iron park bench through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.</p>
+    <p>A procedural wrought-iron park bench with tangent tube scroll feet 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 park-bench render">
       <img src="../assets/park-bench-hero.webp" alt="park-bench 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: 2100 tris, two materials with 510 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 1.080×0.566×0.853 m, LOD ratios in band (5.2 COLLAPSE more aggressive on LOD2), convex collider 106 tris, non-empty glTF. --skip-decimate exits 9 on the LOD1 ratio budget.</div>
+    <div class="callout"><span class="tag">witnesses</span> Recomputed: 2520 tris, two materials with 540 metal and 756 wood faces, UVs in 0..1 with zero AABB overlap, outer AABB 1.295×0.632×0.884 m, grounded zmin, 4 named toes, stretcher gap 1.2 mm, slat gap 0.3 mm, seat span 1.272 m, LOD ratios in band, convex collider 82 tris, hygiene zero, non-empty glTF. --skip-decimate exits 9; --stray-vert 15; --lift-z/--short-feet 16; --float-stretcher 17; --gap-slats 18; --narrow-seat 19.</div>
     <div class="runline">
       <pre id="runCmd">blender --background --python showcase/park-bench/park_bench.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 wrought-iron park bench (scrolled legs, slatted seat and back, armrests) 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 wrought-iron park bench (quarter-circle tube scroll feet tangent to the posts, slatted seat and back, arm scrolls, wood arm caps) then the shipped pipeline: unique-cell UVs, Cycles high-to-low normal bake, LOD chain, convex collider, Unity glTF export.</p>
+<p>Posts, feet, stretchers and arms share named stations (<code>hx</code>, <code>hy</code>, <code>SEAT_Z</code>, <code>ARM_Z</code>, <code>SCROLL_R</code>). A foot is a 6-gon tube about <code>(hy ± R, R)</code> so it is tangent to the post at <code>z=R</code> and plants at <code>z=0</code>. The H-stretcher meets the posts at those stations; slats insert into the post volume without sharing corner verts with the seat rails.</p>
 <p>It asserts <strong>budget conformance</strong> of the generated result. It does not witness an API contract. &quot;It rendered without error&quot; is not a check.</p>
-<p><strong>Composes</strong> skills <code>mesh-editing-and-bmesh</code>, <code>bake-high-to-low</code>, <code>depsgraph-and-evaluated-data</code>, <code>engine-export-presets</code>, and snippets <code>bake_normal_high_to_low.py</code>, <code>setup_bake_target_image.py</code>, <code>lod_chain.py</code> / <code>decimate_to_budget.py</code>, <code>convex_hull_collider.py</code>, <code>export_preset_unity.py</code> (helpers copied, not imported as a package).</p>
+<p><strong>Composes</strong> skills <code>mesh-editing-and-bmesh</code>, <code>bake-high-to-low</code>, <code>depsgraph-and-evaluated-data</code>, <code>engine-export-presets</code>, and snippets <code>bake_normal_high_to_low.py</code>, <code>setup_bake_target_image.py</code>, <code>lod_chain.py</code> / <code>decimate_to_budget.py</code>, <code>convex_hull_collider.py</code>, <code>export_preset_unity.py</code> (helpers copied, not imported as a package). Hygiene combinatorics match <code>examples/mesh-hygiene-audit</code> (copied, not imported).</p>
+<p>Intended size: 1.40 m sitting width, 0.50 m seat depth, 0.43 m seat height, 0.64 m arm height; outer AABB 1.295 × 0.632 × 0.884 m.</p>
 <h2>Budgets</h2>
 <p>Declared as named constants; every gate <strong>recomputes</strong> from the mesh, materials, UVs, evaluated LOD, collider, or export file.</p>
-<p>| Axis | Declared | Measured (4.5.11 / 5.1.2 / 5.2.1) | | --- | --- | --- | | Base triangles | 2000–2200 | 2100 / 2100 / 2100 | | LOD1 ratio | 0.32–0.62 of base | 0.5000 / 0.5000 / 0.4952 | | LOD2 ratio | 0.10–0.35 of base | 0.2200 / 0.2200 / 0.1400 | | Materials | exactly 2 distinct, ≥48 metal faces | 2 slots, 510 metal | | UVs | in <code>0..1</code>, AABB overlap ≤ 1e-5 | in range, overlap 0 | | Outer AABB | (1.080, 0.566, 0.853) m ± 0.01 | (1.0800, 0.5657, 0.8531), zmin 0 | | Collider tris | ≤ 140 | 106 | | Export | written, size &gt; 0 | 159868 / 159868 / 159852 bytes |</p>
-<p>DECIMATE COLLAPSE triangle counts are <strong>not</strong> identical across series — 5.2.1 is more aggressive on LOD2. The gate is a ratio band, not an exact count. Bake pixels are stochastic; the gate is <code>has_data</code> plus operator <code>FINISHED</code>, not byte-identity. Construction uses no RNG. Export byte counts differ by 16 B on 5.2.1 (glTF serializer), not a gated axis.</p>
-<p><code>--skip-decimate</code> skips the LOD DECIMATE stage so LOD1 ratio is 1.0 and exit 9 fires. That is the named budget the falsifier violates.</p>
+<p>| Axis | Declared | Measured (4.5.11 / 5.1.2 / 5.2.1) | | --- | --- | --- | | Base triangles | 2200–4200 | 2520 / 2520 / 2520 | | 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, ≥48 metal, ≥24 wood | 2 slots, 540 metal / 756 wood | | UVs | in <code>0..1</code>, AABB overlap ≤ 1e-5 | in range, overlap 0 | | Outer AABB | (1.295, 0.632, 0.884) m ± 0.015 | (1.2945, 0.6314, 0.8840), zmin 0 | | Collider tris | ≤ 180 | 82 | | Export | written, size &gt; 0 | 188164 / 188164 / 188148 bytes |</p>
+<p>Base triangles rose from <strong>2100 to 2520</strong> in the quality pass: box-segment scrolls became 6-gon tubes. Outer AABB widened from 1.080 × 0.566 × 0.853 m to a 1.40 m sitting-width bench.</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 matched 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. 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 toes | 4, each <code>zmin</code> ≤ 0.002 | 4, 0.00000 |</p>
+<h3>Joint fit and seat</h3>
+<p>| Axis | Declared | Measured (all three) | | --- | --- | --- | | Stretcher-to-post BVH gap | ≤ 0.008 m | 0.00120 | | Slat-to-post BVH gap | ≤ 0.008 m | 0.00028 | | Seat span vs <code>2·hx</code> | ± 0.08 m | 1.2720 vs 1.260 |</p>
+<h3>Falsifiers</h3>
+<p>Each violates one named budget. All were run on 4.5.11, 5.1.2 and 5.2.1 and returned the same code on each.</p>
+<p>| Flag | Budget violated | Exit | | --- | --- | --- | | <code>--skip-decimate</code> | LOD1 ratio band | 9 | | <code>--stray-vert</code> | loose vertex count is 0 | 15 | | <code>--lift-z</code> | bounding box <code>zmin</code> is 0 | 16 | | <code>--short-feet</code> | named toes plant at z=0 | 16 | | <code>--float-stretcher</code> | stretcher-to-post BVH gap | 17 | | <code>--gap-slats</code> | slat-to-post BVH gap | 18 | | <code>--narrow-seat</code> | seat span vs <code>2·hx</code> | 19 |</p>
+<p><code>--short-feet</code> lifts only the outward toe verts. After recenter the post join is the AABB <code>zmin</code>, so the AABB gate would still pass; the named-toe stations fail.</p>
 <h2>Run</h2>
 <pre><code>blender --background --python park_bench.py --
 blender --background --python park_bench.py -- --skip-decimate
+blender --background --python park_bench.py -- --stray-vert
+blender --background --python park_bench.py -- --lift-z
+blender --background --python park_bench.py -- --short-feet
+blender --background --python park_bench.py -- --float-stretcher
+blender --background --python park_bench.py -- --gap-slats
+blender --background --python park_bench.py -- --narrow-seat
 blender --background --python park_bench.py -- --output bench.png</code></pre>
-<p>Smoke does not pass <code>--output</code> or <code>--skip-decimate</code>.</p>
+<p>Smoke passes no flags.</p>
 <h2>Exit codes</h2>
-<p>File-local. <code>9</code> is a valid check code. <code>10</code> is reserved for <code>gallery_framing.check_framing</code> on the <code>--output</code> path.</p>
-<p>| Code | Meaning | | --- | --- | | 0 | Success | | 1 | Uncaught exception (FATAL wrapper) | | 2 | argparse / usage | | 3 | Mesh did not build / no UV layer | | 4 | Base triangle count outside range | | 5 | Material count ≠ 2 distinct slots, or wood/metal faces missing | | 6 | UVs outside 0..1 | | 7 | UV AABB overlap above tolerance | | 8 | World AABB off declared outer size | | 9 | LOD ratio band (<code>--skip-decimate</code> lands here) | | 10 | Framing gate (render path only) | | 11 | Collider triangle count above ceiling | | 12 | Bake did not finish or image has no data | | 13 | Export file missing or empty | | 14 | <code>--output</code> produced no file |</p>
+<p>File-local. <code>9</code> is a valid check code. <code>10</code> is reserved for <code>gallery_framing.check_framing</code> on the <code>--output</code> path. <code>15</code>–<code>19</code> are the hygiene and joint-fit family.</p>
+<p>| Code | Meaning | | --- | --- | | 0 | Success | | 1 | Uncaught exception (FATAL wrapper) | | 2 | argparse / usage | | 3 | Mesh did not build / no UV layer | | 4 | Base triangle count outside range | | 5 | Material count ≠ 2 distinct slots, or wood/metal faces missing | | 6 | UVs outside 0..1 | | 7 | UV AABB overlap above tolerance | | 8 | World AABB off declared outer size | | 9 | LOD ratio band (<code>--skip-decimate</code> lands here) | | 10 | Framing gate (render path only) | | 11 | Collider triangle count above ceiling | | 12 | Bake did not finish or image has no data | | 13 | Export file missing or empty | | 14 | <code>--output</code> produced no file | | 15 | Hygiene (<code>--stray-vert</code> lands here) | | 16 | Grounded zmin / named toes (<code>--lift-z</code>, <code>--short-feet</code>) | | 17 | Stretcher-to-post gap (<code>--float-stretcher</code>) | | 18 | Slat-to-post gap (<code>--gap-slats</code>) | | 19 | Seat span (<code>--narrow-seat</code>) |</p>
     </section>
     <section class="detail-section src">
       <h2>Source</h2>
@@ -284,18 +301,25 @@ <h2>Source</h2>
       </div>
       <pre><span class="s">&quot;&quot;&quot;Game-ready park bench — a showcase piece, not an example.
 
-Asserts budget conformance of a procedural wrought-iron bench (scrolled
-legs, slatted seat and back) 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 wrought-iron bench (quarter-
+circle scroll feet tangent to the posts, slatted seat and back, arm
+scrolls) after composing shipped pipeline pieces: bmesh construction,
+UVs, two materials, high-to-low normal bake, LOD chain, convex collider,
+Unity glTF export.
+
+Posts, feet, stretchers and arms share named stations (hx, hy, SEAT_Z,
+ARM_Z, SCROLL_R). A foot is a quarter-circle about (hy ± R, R) so it is
+tangent to the post at z=R and plants at z=0.
 
 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`` LOD, ``--stray-vert`` hygiene, ``--lift-z``
+zmin, ``--short-feet`` named toes, ``--float-stretcher`` stretcher seat,
+``--gap-slats`` slat-to-rail, ``--narrow-seat`` sitting width.
 
-No RNG. Construction is closed-form. DECIMATE COLLAPSE triangle counts
-are not byte-identical across Blender versions — the LOD gate is a
-ratio band, not an exact count.
+No RNG. Slat widths use closed-form ``sin(i)``. DECIMATE COLLAPSE
+triangle counts are not byte-identical across Blender versions — the LOD
+gate is a ratio band, not an exact count.
 
     blender --background --python park_bench.py --
     blender --background --python park_bench.py -- --skip-decimate
@@ -311,6 +335,7 @@ <h2>Source</h2>
 <span class="k">import</span> bmesh
 <span class="k">import</span> bpy
 <span class="k">from</span> mathutils <span class="k">import</span> Euler, Vector
+<span class="k">from</span> mathutils.bvhtree <span class="k">import</span> BVHTree
 
 _REPO = os.path.abspath(
     os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir, os.pardir)
@@ -319,22 +344,30 @@ <h2>Source</h2>
 sys.dont_write_bytecode = <span class="k">True</span>
 <span class="k">import</span> gallery_framing  <span class="c"># noqa: E402</span>
 
-SEAT_W = <span class="n">1.18</span>
-SEAT_D = <span class="n">0.46</span>
-SEAT_Z = <span class="n">0.44</span>
-N_SEAT = <span class="n">6</span>
-N_BACK = <span class="n">4</span>
-SLAT_T = <span class="n">0.032</span>
-BACK_H = <span class="n">0.40</span>
-IRON_T = <span class="n">0.026</span>
-SCROLL_R = <span class="n">0.10</span>
+SEAT_W = <span class="n">1.40</span>
+SEAT_D = <span class="n">0.50</span>
+SEAT_Z = <span class="n">0.43</span>
+N_SEAT = <span class="n">7</span>
+N_BACK = <span class="n">5</span>
+SLAT_T = <span class="n">0.030</span>
+BACK_H = <span class="n">0.38</span>
+IRON_T = <span class="n">0.024</span>
+SCROLL_R = <span class="n">0.11</span>
 SCROLL_N = <span class="n">12</span>
-ARM_Z = <span class="n">0.62</span>
-
-BBOX_TOL = <span class="n">0.01</span>
-OUTER_SIZE = (<span class="n">1.080</span>, <span class="n">0.566</span>, <span class="n">0.853</span>)
-BASE_TRIS_MIN = <span class="n">2000</span>
-BASE_TRIS_MAX = <span class="n">2200</span>
+ARM_Z = <span class="n">0.64</span>
+ARM_SCROLL_R = <span class="n">0.055</span>
+STRETCHER_Z = <span class="n">0.16</span>
+POST_INSET_X = <span class="n">0.07</span>
+POST_INSET_Y = <span class="n">0.045</span>
+HX = SEAT_W / <span class="n">2.0</span> - POST_INSET_X
+HY = SEAT_D / <span class="n">2.0</span> - POST_INSET_Y
+SEAT_SPAN = <span class="n">2.0</span> * HX
+SEAT_SPAN_TOL = <span class="n">0.08</span>
+
+BBOX_TOL = <span class="n">0.015</span>
+OUTER_SIZE = (<span class="n">1.295</span>, <span class="n">0.632</span>, <span class="n">0.884</span>)
+BASE_TRIS_MIN = <span class="n">2200</span>
+BASE_TRIS_MAX = <span class="n">4200</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 +377,25 @@ <h2>Source</h2>
 MATERIAL_COUNT = <span class="n">2</span>
 UV_EPS = <span class="n">1e-4</span>
 UV_OVERLAP_MAX = <span class="n">1e-5</span>
-COLLIDER_TRIS_MAX = <span class="n">140</span>
+COLLIDER_TRIS_MAX = <span class="n">180</span>
 BAKE_RES = <span class="n">256</span>
 CAGE_EXTRUSION = <span class="n">0.08</span>
 METAL_FACES_MIN = <span class="n">48</span>
 WOOD_FACES_MIN = <span class="n">24</span>
+ZMIN_EPS = <span class="n">1e-4</span>
+DOUBLES_EPS = <span class="n">1e-5</span>
+AREA_EPS = <span class="n">1e-10</span>
+ZFIGHT_EPS = <span class="n">1e-4</span>
+ZFIGHT_COS = <span class="n">0.998</span>
+STRETCHER_GAP_MAX = <span class="n">0.008</span>
+SLAT_GAP_MAX = <span class="n">0.008</span>
+TOE_COUNT = <span class="n">4</span>
+TOE_ZMIN_MAX = <span class="n">0.002</span>
+FLOAT_STRETCHER = <span class="n">0.10</span>
+GAP_SLAT = <span class="n">0.10</span>
+SHORT_FOOT = <span class="n">0.16</span>
+LIFT_Z = <span class="n">0.05</span>
+NARROW_SEAT = <span class="n">0.55</span>
 
 WOOD_IDX = <span class="n">0</span>
 METAL_IDX = <span class="n">1</span>
@@ -418,16 +465,70 @@ <h2>Source</h2>
     )
 
 
-<span class="k">def</span> add_arc_yz(bm, x, cy, cz, radius, a0, a1, n, thick, mat_idx):
+<span class="k">def</span> add_arc_yz(bm, x, cy, cz, radius, a0, a1, n, thick, mat_idx, t0=<span class="n">0.0</span>, t1=<span class="n">1.0</span>):
     pts = []
     <span class="k">for</span> i <span class="k">in</span> range(n + <span class="n">1</span>):
-        t = i / n
+        t = t0 + (t1 - t0) * (i / n)
         ang = a0 + (a1 - a0) * t
-        pts.append((x, cy + radius * math.cos(ang), cz + radius * math.sin(ang)))
-    verts = []
-    <span class="k">for</span> p0, p1 <span class="k">in</span> zip(pts, pts[<span class="n">1</span>:]):
-        verts.extend(add_oriented_box(bm, p0, p1, (thick, thick), mat_idx))
-    <span class="k">return</span> verts
+        pts.append(Vector((x, cy + radius * math.cos(ang), cz + radius * math.sin(ang))))
+    rings = <span class="n">6</span>
+    r = thick * <span class="n">0.5</span>
+    ring_verts = []
+    <span class="k">for</span> i, p <span class="k">in</span> enumerate(pts):
+        <span class="k">if</span> i &lt; n:
+            tangent = (pts[i + <span class="n">1</span>] - p).normalized()
+        <span class="k">else</span>:
+            tangent = (p - pts[i - <span class="n">1</span>]).normalized()
+        side = tangent.cross(Vector((<span class="n">1.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>)))
+        <span class="k">if</span> side.length &lt; <span class="n">1e-6</span>:
+            side = tangent.cross(Vector((<span class="n">0.0</span>, <span class="n">1.0</span>, <span class="n">0.0</span>)))
+        side.normalize()
+        up = tangent.cross(side).normalized()
+        ring = []
+        <span class="k">for</span> k <span class="k">in</span> range(rings):
+            ang = (<span class="n">2.0</span> * math.pi * k) / rings
+            offset = side * math.cos(ang) * r + up * math.sin(ang) * r
+            ring.append(bm.verts.new(p + offset))
+        ring_verts.append(ring)
+    bm.verts.ensure_lookup_table()
+    bm.faces.ensure_lookup_table()
+    <span class="k">for</span> a, b <span class="k">in</span> zip(ring_verts, ring_verts[<span class="n">1</span>:]):
+        <span class="k">for</span> k <span class="k">in</span> range(rings):
+            k2 = (k + <span class="n">1</span>) % rings
+            face = bm.faces.new((a[k], a[k2], b[k2], b[k]))
+            face.material_index = mat_idx
+    <span class="k">for</span> end_i, p <span class="k">in</span> ((<span class="n">0</span>, pts[<span class="n">0</span>]), (-<span class="n">1</span>, pts[-<span class="n">1</span>])):
+        center = bm.verts.new(p)
+        ring = ring_verts[end_i]
+        <span class="k">for</span> k <span class="k">in</span> range(rings):
+            k2 = (k + <span class="n">1</span>) % rings
+            <span class="k">if</span> end_i == <span class="n">0</span>:
+                face = bm.faces.new((center, ring[k2], ring[k]))
+            <span class="k">else</span>:
+                face = bm.faces.new((center, ring[k], ring[k2]))
+            face.material_index = mat_idx
+    <span class="k">return</span> [v <span class="k">for</span> ring <span class="k">in</span> ring_verts <span class="k">for</span> v <span class="k">in</span> ring]
+
+
+<span class="k">def</span> add_foot_scroll(bm, x, y_post, y_out, thick, mat_idx):
+    <span class="s">&quot;&quot;&quot;Quarter-circle from post join (y_post, R) to toe (y_out, 0).&quot;&quot;&quot;</span>
+    cy = y_out
+    cz = SCROLL_R
+    <span class="k">if</span> y_out &lt; y_post:
+        a0, a1 = <span class="n">0.0</span>, -math.pi / <span class="n">2.0</span>
+    <span class="k">else</span>:
+        a0, a1 = math.pi, <span class="n">1.5</span> * math.pi
+    <span class="k">return</span> add_arc_yz(
+        bm, x, cy, cz, SCROLL_R, a0, a1, SCROLL_N, thick, mat_idx, t0=<span class="n">0.08</span>, t1=<span class="n">1.0</span>
+    )
+
+
+<span class="k">def</span> add_arm_scroll(bm, x, y_post, thick, mat_idx):
+    cy = y_post - ARM_SCROLL_R
+    cz = ARM_Z
+    <span class="k">return</span> add_arc_yz(
+        bm, x, cy, cz, ARM_SCROLL_R, <span class="n">0.0</span>, -math.pi / <span class="n">2.0</span>, <span class="n">8</span>, thick, mat_idx, t0=<span class="n">0.08</span>, t1=<span class="n">1.0</span>
+    )
 
 
 <span class="k">def</span> pack_uvs(bm, margin=<span class="n">0.08</span>):
@@ -473,34 +574,70 @@ <h2>Source</h2>
             )
 
 
-<span class="k">def</span> build_bench_mesh(name, bevel_offset, bevel_segments):
+<span class="k">def</span> build_bench_mesh(
+    name,
+    bevel_offset,
+    bevel_segments,
+    float_stretcher=<span class="k">False</span>,
+    gap_slats=<span class="k">False</span>,
+    short_feet=<span class="k">False</span>,
+    narrow_seat=<span class="k">False</span>,
+):
     bm = bmesh.new()
     <span class="k">try</span>:
         wood = []
-        hx = SEAT_W / <span class="n">2.0</span> - <span class="n">0.08</span>
-        hy = SEAT_D / <span class="n">2.0</span> - <span class="n">0.05</span>
-        <span class="c"># Span past the post centers (±hx) so slats insert into the iron frame.</span>
-        slat_span = <span class="n">2.0</span> * hx + IRON_T
-        usable = SEAT_D - <span class="n">0.08</span>
-        slat_w = usable / N_SEAT
-        y0 = -hy + slat_w / <span class="n">2.0</span> + <span class="n">0.01</span>
+        t = IRON_T
+        hx, hy = HX, HY
+        slat_span = SEAT_SPAN + t * <span class="n">0.50</span>
+        <span class="k">if</span> gap_slats:
+            slat_span = SEAT_SPAN - IRON_T - <span class="n">0.024</span>
+        <span class="k">if</span> narrow_seat:
+            slat_span = SEAT_SPAN * NARROW_SEAT
+
+        usable = <span class="n">2.0</span> * hy - <span class="n">0.06</span>
+        gap = <span class="n">0.010</span>
+        widths = []
         <span class="k">for</span> i <span class="k">in</span> range(N_SEAT):
-            y = y0 + i * slat_w
+            widths.append(<span class="n">1.0</span> + <span class="n">0.10</span> * math.sin(i * <span class="n">1.7</span> + <span class="n">0.3</span>))
+        scale = (usable - gap * (N_SEAT - <span class="n">1</span>)) / sum(widths)
+        y_cursor = -hy + <span class="n">0.03</span>
+        <span class="k">for</span> i, w <span class="k">in</span> enumerate(widths):
+            slat_w = w * scale
+            y = y_cursor + slat_w * <span class="n">0.5</span>
             wood.extend(
                 add_box(
                     bm,
                     (<span class="n">0.0</span>, y, SEAT_Z + SLAT_T / <span class="n">2.0</span>),
-                    (slat_span, slat_w * <span class="n">0.78</span>, SLAT_T),
+                    (slat_span, slat_w * <span class="n">0.92</span>, SLAT_T),
                     WOOD_IDX,
                 )
             )
-        <span class="k">for</span> i <span class="k">in</span> range(N_BACK):
-            z = SEAT_Z + SLAT_T + <span class="n">0.05</span> + i * (BACK_H / N_BACK)
+            y_cursor += slat_w + gap
+
+        back_span = BACK_H - <span class="n">0.04</span>
+        bwidths = [<span class="n">1.0</span> + <span class="n">0.08</span> * math.sin(i * <span class="n">1.4</span> + <span class="n">0.8</span>) <span class="k">for</span> i <span class="k">in</span> range(N_BACK)]
+        bscale = (back_span - gap * (N_BACK - <span class="n">1</span>)) / sum(bwidths)
+        z_cursor = SEAT_Z + SLAT_T + <span class="n">0.04</span>
+        <span class="k">for</span> w <span class="k">in</span> bwidths:
+            slat_h = w * bscale
+            z = z_cursor + slat_h * <span class="n">0.5</span>
             wood.extend(
                 add_box(
                     bm,
                     (<span class="n">0.0</span>, hy, z),
-                    (slat_span, SLAT_T, slat_w * <span class="n">0.72</span>),
+                    (slat_span, SLAT_T, slat_h * <span class="n">0.90</span>),
+                    WOOD_IDX,
+                )
+            )
+            z_cursor += slat_h + gap
+
+        <span class="k">for</span> xsign <span class="k">in</span> (-<span class="n">1.0</span>, <span class="n">1.0</span>):
+            x = xsign * hx
+            wood.extend(
+                add_box(
+                    bm,
+                    (x, <span class="n">0.0</span>, ARM_Z + t * <span class="n">0.5</span> + SLAT_T * <span class="n">0.5</span>),
+                    (SLAT_T * <span class="n">1.15</span>, <span class="n">2.0</span> * hy + t, SLAT_T),
                     WOOD_IDX,
                 )
             )
@@ -519,14 +656,13 @@ <h2>Source</h2>
             <span class="k">for</span> f <span class="k">in</span> ret.get(<span class="s">&quot;faces&quot;</span>) <span class="k">or</span> []:
                 f.material_index = WOOD_IDX
 
-        t = IRON_T
-        add_box(bm, (<span class="n">0.0</span>, -hy, SEAT_Z - <span class="n">0.018</span>), (SEAT_W - <span class="n">0.10</span>, t * <span class="n">1.15</span>, t), METAL_IDX)
-        add_box(bm, (<span class="n">0.0</span>, hy, SEAT_Z - <span class="n">0.018</span>), (SEAT_W - <span class="n">0.10</span>, t * <span class="n">1.15</span>, t), METAL_IDX)
+        add_box(bm, (<span class="n">0.0</span>, -hy, SEAT_Z - t * <span class="n">0.35</span>), (SEAT_SPAN, t, t), METAL_IDX)
+        add_box(bm, (<span class="n">0.0</span>, hy, SEAT_Z - t * <span class="n">0.35</span>), (SEAT_SPAN, t, t), METAL_IDX)
         <span class="k">for</span> xsign <span class="k">in</span> (-<span class="n">1.0</span>, <span class="n">1.0</span>):
             add_box(
                 bm,
-                (xsign * hx, <span class="n">0.0</span>, SEAT_Z - <span class="n">0.018</span>),
-                (t * <span class="n">1.15</span>, SEAT_D - <span class="n">0.08</span>, t),
+                (xsign * hx, <span class="n">0.0</span>, SEAT_Z - t * <span class="n">0.35</span>),
+                (t, <span class="n">2.0</span> * hy, t),
                 METAL_IDX,
             )
 
@@ -534,68 +670,49 @@ <h2>Source</h2>
         <span class="k">for</span> xsign <span class="k">in</span> (-<span class="n">1.0</span>, <span class="n">1.0</span>):
             x = xsign * hx
             add_oriented_box(
-                bm, (x, hy, SEAT_Z), (x, hy, back_top), (t, t), METAL_IDX
+                bm, (x, hy, SCROLL_R), (x, hy, back_top), (t, t), METAL_IDX
             )
             add_oriented_box(
-                bm, (x, -hy, SEAT_Z), (x, -hy, ARM_Z), (t, t), METAL_IDX
+                bm, (x, -hy, SCROLL_R), (x, -hy, ARM_Z), (t, t), METAL_IDX
             )
             add_oriented_box(
-                bm, (x, -hy, ARM_Z), (x, hy, ARM_Z), (t * <span class="n">0.9</span>, t * <span class="n">0.9</span>), METAL_IDX
-            )
-            add_oriented_box(
-                bm,
-                (x, -hy, SCROLL_R + <span class="n">0.02</span>),
-                (x, -hy, SEAT_Z),
-                (t, t),
-                METAL_IDX,
-            )
-            add_oriented_box(
-                bm,
-                (x, hy, SCROLL_R + <span class="n">0.02</span>),
-                (x, hy, SEAT_Z),
-                (t, t),
-                METAL_IDX,
-            )
-            add_arc_yz(
-                bm,
-                x,
-                -hy + <span class="n">0.01</span>,
-                SCROLL_R,
-                SCROLL_R,
-                math.pi / <span class="n">2.0</span>,
-                math.pi + <span class="n">0.45</span>,
-                SCROLL_N,
-                t,
-                METAL_IDX,
-            )
-            add_arc_yz(
-                bm,
-                x,
-                hy - <span class="n">0.01</span>,
-                SCROLL_R,
-                SCROLL_R,
-                math.pi / <span class="n">2.0</span>,
-                -<span class="n">0.45</span>,
-                SCROLL_N,
-                t,
-                METAL_IDX,
-            )
-            add_arc_yz(
-                bm,
-                x,
-                -hy - <span class="n">0.02</span>,
-                ARM_Z - <span class="n">0.04</span>,
-                <span class="n">0.07</span>,
-                math.pi * <span class="n">0.15</span>,
-                math.pi * <span class="n">0.95</span>,
-                <span class="n">10</span>,
-                t * <span class="n">0.85</span>,
-                METAL_IDX,
+                bm, (x, -hy, ARM_Z), (x, hy, ARM_Z), (t * <span class="n">0.95</span>, t * <span class="n">0.95</span>), METAL_IDX
             )
-
-        add_box(bm, (<span class="n">0.0</span>, hy, back_top), (SEAT_W - <span class="n">0.12</span>, t, t), METAL_IDX)
-        add_box(bm, (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.18</span>), (SEAT_W - <span class="n">0.22</span>, t * <span class="n">0.9</span>, t * <span class="n">0.9</span>), METAL_IDX)
-        add_box(bm, (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.18</span>), (t * <span class="n">0.9</span>, SEAT_D - <span class="n">0.14</span>, t * <span class="n">0.9</span>), METAL_IDX)
+            add_foot_scroll(bm, x, -hy, -hy - SCROLL_R, t, METAL_IDX)
+            add_foot_scroll(bm, x, hy, hy + SCROLL_R, t, METAL_IDX)
+            add_arm_scroll(bm, x, -hy, t * <span class="n">0.90</span>, METAL_IDX)
+
+        add_box(bm, (<span class="n">0.0</span>, hy, back_top), (SEAT_SPAN, t, t), METAL_IDX)
+
+        st_trim = FLOAT_STRETCHER <span class="k">if</span> float_stretcher <span class="k">else</span> <span class="n">0.0</span>
+        yx = hx - st_trim
+        add_oriented_box(
+            bm,
+            (-yx, -hy, STRETCHER_Z),
+            (-yx, hy, STRETCHER_Z),
+            (t * <span class="n">0.9</span>, t * <span class="n">0.9</span>),
+            METAL_IDX,
+        )
+        add_oriented_box(
+            bm,
+            (yx, -hy, STRETCHER_Z),
+            (yx, hy, STRETCHER_Z),
+            (t * <span class="n">0.9</span>, t * <span class="n">0.9</span>),
+            METAL_IDX,
+        )
+        cx_end = yx - t * <span class="n">0.40</span>
+        add_oriented_box(
+            bm,
+            (-cx_end, <span class="n">0.0</span>, STRETCHER_Z),
+            (cx_end, <span class="n">0.0</span>, STRETCHER_Z),
+            (t * <span class="n">0.9</span>, t * <span class="n">0.9</span>),
+            METAL_IDX,
+        )
+
+        <span class="k">if</span> short_feet:
+            <span class="k">for</span> v <span class="k">in</span> bm.verts:
+                <span class="k">if</span> v.co.z &lt; SCROLL_R * <span class="n">0.55</span> <span class="k">and</span> abs(v.co.y) &gt; hy + SCROLL_R * <span class="n">0.35</span>:
+                    v.co.z += SHORT_FOOT
 
         xs = [v.co.x <span class="k">for</span> v <span class="k">in</span> bm.verts]
         ys = [v.co.y <span class="k">for</span> v <span class="k">in</span> bm.verts]
@@ -610,15 +727,18 @@ <h2>Source</h2>
             <span class="k">if</span> v.co.z &lt; <span class="n">0.0</span>:
                 v.co.z = <span class="n">0.0</span>
 
+        ngons = [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> ngons:
+            bmesh.ops.triangulate(bm, faces=ngons)
         pack_uvs(bm)
         bmesh.ops.recalc_face_normals(bm, faces=list(bm.faces))
         <span class="k">for</span> face <span class="k">in</span> bm.faces:
-            face.smooth = <span class="k">False</span>
+            face.smooth = face.material_index == METAL_IDX
         me = bpy.data.meshes.new(name)
         bm.to_mesh(me)
         me.update()
         <span class="k">for</span> poly <span class="k">in</span> me.polygons:
-            poly.use_smooth = <span class="k">False</span>
+            poly.use_smooth = poly.material_index == METAL_IDX
     <span class="k">finally</span>:
         bm.free()
     out = bpy.data.objects.new(name, me)
@@ -626,13 +746,25 @@ <h2>Source</h2>
     <span class="k">return</span> out
 
 
-<span class="k">def</span> principled(name, color, metallic, roughness):
+<span class="k">def</span> principled(name, color, metallic, roughness, noise_scale=<span class="n">0.0</span>, wear=<span class="k">None</span>):
     mat = bpy.data.materials.new(name)
     mat.use_nodes = <span class="k">True</span>
-    bsdf = mat.node_tree.nodes[<span class="s">&quot;Principled BSDF&quot;</span>]
+    nt = mat.node_tree
+    bsdf = nt.nodes[<span class="s">&quot;Principled BSDF&quot;</span>]
     bsdf.inputs[<span class="s">&quot;Base Color&quot;</span>].default_value = color
     bsdf.inputs[<span class="s">&quot;Metallic&quot;</span>].default_value = metallic
     bsdf.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = roughness
+    <span class="k">if</span> noise_scale &gt; <span class="n">0.0</span> <span class="k">and</span> wear <span class="k">is</span> <span class="k">not</span> <span class="k">None</span>:
+        tex = nt.nodes.new(<span class="s">&quot;ShaderNodeTexNoise&quot;</span>)
+        tex.inputs[<span class="s">&quot;Scale&quot;</span>].default_value = noise_scale
+        tex.inputs[<span class="s">&quot;Detail&quot;</span>].default_value = <span class="n">6.0</span>
+        mix = nt.nodes.new(<span class="s">&quot;ShaderNodeMix&quot;</span>)
+        mix.data_type = <span class="s">&quot;RGBA&quot;</span>
+        mix.inputs[<span class="s">&quot;A&quot;</span>].default_value = color
+        mix.inputs[<span class="s">&quot;B&quot;</span>].default_value = wear
+        fac = mix.inputs.get(<span class="s">&quot;Factor&quot;</span>) <span class="k">or</span> mix.inputs.get(<span class="s">&quot;Fac&quot;</span>)
+        nt.links.new(tex.outputs[<span class="s">&quot;Fac&quot;</span>], fac)
+        nt.links.new(mix.outputs[<span class="s">&quot;Result&quot;</span>], bsdf.inputs[<span class="s">&quot;Base Color&quot;</span>])
     <span class="k">return</span> mat
 
 
@@ -647,10 +779,11 @@ <h2>Source</h2>
 
 
 <span class="k">def</span> world_bbox(obj):
-    corners = [obj.matrix_world @ Vector(c) <span class="k">for</span> c <span class="k">in</span> obj.bound_box]
-    xs = [c.x <span class="k">for</span> c <span class="k">in</span> corners]
-    ys = [c.y <span class="k">for</span> c <span class="k">in</span> corners]
-    zs = [c.z <span class="k">for</span> c <span class="k">in</span> corners]
+    mat = obj.matrix_world
+    pts = [mat @ v.co <span class="k">for</span> v <span class="k">in</span> obj.data.vertices]
+    xs = [p.x <span class="k">for</span> p <span class="k">in</span> pts]
+    ys = [p.y <span class="k">for</span> p <span class="k">in</span> pts]
+    zs = [p.z <span class="k">for</span> p <span class="k">in</span> pts]
     <span class="k">return</span> (min(xs), min(ys), min(zs), max(xs), max(ys), max(zs))
 
 
@@ -713,6 +846,203 @@ <h2>Source</h2>
     <span class="k">return</span> collider
 
 
+<span class="k">def</span> face_area(me, poly):
+    vs = [me.vertices[i].co <span class="k">for</span> i <span class="k">in</span> poly.vertices]
+    <span class="k">if</span> len(vs) &lt; <span class="n">3</span>:
+        <span class="k">return</span> <span class="n">0.0</span>
+    v0 = vs[<span class="n">0</span>]
+    area = <span class="n">0.0</span>
+    <span class="k">for</span> i <span class="k">in</span> range(<span class="n">1</span>, len(vs) - <span class="n">1</span>):
+        area += (vs[i] - v0).cross(vs[i + <span class="n">1</span>] - v0).length * <span class="n">0.5</span>
+    <span class="k">return</span> area
+
+
+<span class="k">def</span> hygiene_audit(me):
+    nv, ne, nf = len(me.vertices), len(me.edges), len(me.polygons)
+    ngons = sum(<span class="n">1</span> <span class="k">for</span> p <span class="k">in</span> me.polygons <span class="k">if</span> len(p.vertices) &gt; <span class="n">4</span>)
+    zero_area = sum(<span class="n">1</span> <span class="k">for</span> p <span class="k">in</span> me.polygons <span class="k">if</span> face_area(me, p) &lt;= AREA_EPS)
+    bm = bmesh.new()
+    <span class="k">try</span>:
+        bm.from_mesh(me)
+        loose_v = sum(<span class="n">1</span> <span class="k">for</span> v <span class="k">in</span> bm.verts <span class="k">if</span> len(v.link_edges) == <span class="n">0</span>)
+        loose_e = sum(<span class="n">1</span> <span class="k">for</span> e <span class="k">in</span> bm.edges <span class="k">if</span> len(e.link_faces) == <span class="n">0</span>)
+        nonman = sum(<span class="n">1</span> <span class="k">for</span> e <span class="k">in</span> bm.edges <span class="k">if</span> <span class="k">not</span> e.is_manifold)
+        ret = bmesh.ops.find_doubles(bm, verts=list(bm.verts), dist=DOUBLES_EPS)
+        doubles = len(ret.get(<span class="s">&quot;targetmap&quot;</span>) <span class="k">or</span> {})
+    <span class="k">finally</span>:
+        bm.free()
+    <span class="k">return</span> {
+        <span class="s">&quot;nv&quot;</span>: nv, <span class="s">&quot;ne&quot;</span>: ne, <span class="s">&quot;nf&quot;</span>: nf, <span class="s">&quot;ngons&quot;</span>: ngons,
+        <span class="s">&quot;loose_v&quot;</span>: loose_v, <span class="s">&quot;loose_e&quot;</span>: loose_e, <span class="s">&quot;nonman&quot;</span>: nonman,
+        <span class="s">&quot;zero_area&quot;</span>: zero_area, <span class="s">&quot;doubles&quot;</span>: doubles, <span class="s">&quot;euler&quot;</span>: nv - ne + nf,
+    }
+
+
+<span class="k">def</span> zfight_pairs(me):
+    data = [
+        (p.center.copy(), p.normal.copy(), frozenset(p.vertices))
+        <span class="k">for</span> p <span class="k">in</span> me.polygons
+    ]
+    eps2 = ZFIGHT_EPS * ZFIGHT_EPS
+    count = <span class="n">0</span>
+    <span class="k">for</span> i <span class="k">in</span> range(len(data)):
+        ci, ni, vi = data[i]
+        <span class="k">for</span> j <span class="k">in</span> range(i + <span class="n">1</span>, len(data)):
+            cj, nj, vj = data[j]
+            <span class="k">if</span> (cj - ci).length_squared &gt; eps2:
+                <span class="k">continue</span>
+            <span class="k">if</span> abs(ni.dot(nj)) &lt;= ZFIGHT_COS:
+                <span class="k">continue</span>
+            <span class="k">if</span> vi &amp; vj:
+                <span class="k">continue</span>
+            count += <span class="n">1</span>
+    <span class="k">return</span> count
+
+
+<span class="k">def</span> shells(me):
+    neighbors = [[] <span class="k">for</span> _ <span class="k">in</span> range(len(me.vertices))]
+    <span class="k">for</span> edge <span class="k">in</span> me.edges:
+        a, b = edge.vertices
+        neighbors[a].append(b)
+        neighbors[b].append(a)
+    seen = [<span class="k">False</span>] * len(me.vertices)
+    groups = []
+    <span class="k">for</span> start <span class="k">in</span> range(len(me.vertices)):
+        <span class="k">if</span> seen[start]:
+            <span class="k">continue</span>
+        seen[start] = <span class="k">True</span>
+        stack = [start]
+        group = []
+        <span class="k">while</span> stack:
+            current = stack.pop()
+            group.append(current)
+            <span class="k">for</span> nxt <span class="k">in</span> neighbors[current]:
+                <span class="k">if</span> <span class="k">not</span> seen[nxt]:
+                    seen[nxt] = <span class="k">True</span>
+                    stack.append(nxt)
+        groups.append(group)
+    <span class="k">return</span> groups
+
+
+<span class="k">def</span> shell_aabb(me, group):
+    pts = [me.vertices[i].co <span class="k">for</span> i <span class="k">in</span> group]
+    <span class="k">return</span> (
+        min(p.x <span class="k">for</span> p <span class="k">in</span> pts), min(p.y <span class="k">for</span> p <span class="k">in</span> pts), min(p.z <span class="k">for</span> p <span class="k">in</span> pts),
+        max(p.x <span class="k">for</span> p <span class="k">in</span> pts), max(p.y <span class="k">for</span> p <span class="k">in</span> pts), max(p.z <span class="k">for</span> p <span class="k">in</span> pts),
+    )
+
+
+<span class="k">def</span> mat_of(me, group):
+    member = set(group)
+    <span class="k">for</span> poly <span class="k">in</span> me.polygons:
+        <span class="k">if</span> all(i <span class="k">in</span> member <span class="k">for</span> i <span class="k">in</span> poly.vertices):
+            <span class="k">return</span> poly.material_index
+    <span class="k">return</span> <span class="k">None</span>
+
+
+<span class="k">def</span> shell_bvh_gap(me, ga, gb):
+    bm_a = bmesh.new()
+    bm_b = bmesh.new()
+    <span class="k">try</span>:
+        bm_a.from_mesh(me)
+        bm_b.from_mesh(me)
+        keep_a, keep_b = set(ga), set(gb)
+        drop_a = [f <span class="k">for</span> f <span class="k">in</span> bm_a.faces <span class="k">if</span> <span class="k">not</span> all(v.index <span class="k">in</span> keep_a <span class="k">for</span> v <span class="k">in</span> f.verts)]
+        drop_b = [f <span class="k">for</span> f <span class="k">in</span> bm_b.faces <span class="k">if</span> <span class="k">not</span> all(v.index <span class="k">in</span> keep_b <span class="k">for</span> v <span class="k">in</span> f.verts)]
+        <span class="k">if</span> drop_a:
+            bmesh.ops.delete(bm_a, geom=drop_a, context=<span class="s">&quot;FACES&quot;</span>)
+        <span class="k">if</span> drop_b:
+            bmesh.ops.delete(bm_b, geom=drop_b, context=<span class="s">&quot;FACES&quot;</span>)
+        <span class="k">if</span> <span class="k">not</span> bm_a.faces <span class="k">or</span> <span class="k">not</span> bm_b.faces:
+            <span class="k">return</span> <span class="n">1e9</span>
+        tree = BVHTree.FromBMesh(bm_b)
+        best = <span class="n">1e9</span>
+        <span class="k">for</span> v <span class="k">in</span> bm_a.verts:
+            hit = tree.find_nearest(v.co)
+            <span class="k">if</span> hit[<span class="n">0</span>] <span class="k">is</span> <span class="k">not</span> <span class="k">None</span>:
+                best = min(best, hit[<span class="n">3</span>])
+        <span class="k">for</span> f <span class="k">in</span> bm_a.faces:
+            hit = tree.find_nearest(f.calc_center_median())
+            <span class="k">if</span> hit[<span class="n">0</span>] <span class="k">is</span> <span class="k">not</span> <span class="k">None</span>:
+                best = min(best, hit[<span class="n">3</span>])
+        <span class="k">return</span> best
+    <span class="k">finally</span>:
+        bm_a.free()
+        bm_b.free()
+
+
+<span class="k">def</span> add_stray_vert(me):
+    bm = bmesh.new()
+    <span class="k">try</span>:
+        bm.from_mesh(me)
+        bm.verts.new((<span class="n">0.0</span>, <span class="n">0.0</span>, SEAT_Z + <span class="n">0.12</span>))
+        bm.to_mesh(me)
+        me.update()
+    <span class="k">finally</span>:
+        bm.free()
+
+
+<span class="k">def</span> joint_audit(me):
+    groups = shells(me)
+    posts = []
+    stretchers = []
+    slats = []
+    <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> dz &gt; <span class="n">0.28</span> <span class="k">and</span> dx &lt; <span class="n">0.08</span> <span class="k">and</span> dy &lt; <span class="n">0.08</span>:
+            posts.append((g, a))
+        <span class="k">if</span> mat == METAL_IDX <span class="k">and</span> abs(<span class="n">0.5</span> * (a[<span class="n">2</span>] + a[<span class="n">5</span>]) - STRETCHER_Z) &lt; <span class="n">0.05</span> <span class="k">and</span> max(dx, dy) &gt; <span class="n">0.25</span>:
+            stretchers.append((g, a))
+        <span class="k">if</span> mat == WOOD_IDX <span class="k">and</span> dz &lt; <span class="n">0.08</span> <span class="k">and</span> dx &gt; SEAT_SPAN * <span class="n">0.4</span>:
+            slats.append((g, a))
+    metal_verts = []
+    <span class="k">for</span> poly <span class="k">in</span> me.polygons:
+        <span class="k">if</span> poly.material_index != METAL_IDX:
+            <span class="k">continue</span>
+        <span class="k">for</span> i <span class="k">in</span> poly.vertices:
+            metal_verts.append(me.vertices[i].co)
+    stations = (
+        (HX, HY + SCROLL_R, <span class="n">0.0</span>),
+        (HX, -HY - SCROLL_R, <span class="n">0.0</span>),
+        (-HX, HY + SCROLL_R, <span class="n">0.0</span>),
+        (-HX, -HY - SCROLL_R, <span class="n">0.0</span>),
+    )
+    toes = <span class="n">0</span>
+    toe_z = <span class="n">99.0</span>
+    <span class="k">for</span> sx, sy, sz <span class="k">in</span> stations:
+        nearby = []
+        <span class="k">for</span> co <span class="k">in</span> metal_verts:
+            d = ((co.x - sx) ** <span class="n">2</span> + (co.y - sy) ** <span class="n">2</span>) ** <span class="n">0.5</span>
+            <span class="k">if</span> d &lt; SCROLL_R * <span class="n">0.55</span>:
+                nearby.append(co)
+        <span class="k">if</span> nearby:
+            toes += <span class="n">1</span>
+            toe_z = min(toe_z, min(c.z <span class="k">for</span> c <span class="k">in</span> nearby))
+    st_gap = <span class="n">99.0</span>
+    <span class="k">if</span> stretchers <span class="k">and</span> posts:
+        st_gap = min(shell_bvh_gap(me, s[<span class="n">0</span>], p[<span class="n">0</span>]) <span class="k">for</span> s <span class="k">in</span> stretchers <span class="k">for</span> p <span class="k">in</span> posts)
+    slat_gap = <span class="n">99.0</span>
+    rails = [p <span class="k">for</span> p <span class="k">in</span> posts]
+    <span class="k">if</span> slats <span class="k">and</span> rails:
+        slat_gap = min(shell_bvh_gap(me, s[<span class="n">0</span>], p[<span class="n">0</span>]) <span class="k">for</span> s <span class="k">in</span> slats <span class="k">for</span> p <span class="k">in</span> rails)
+    seat_x = <span class="n">0.0</span>
+    <span class="k">if</span> slats:
+        xs = [v <span class="k">for</span> _g, a <span class="k">in</span> slats <span class="k">for</span> v <span class="k">in</span> (a[<span class="n">0</span>], a[<span class="n">3</span>])]
+        seat_x = max(xs) - min(xs)
+    <span class="k">return</span> {
+        <span class="s">&quot;toes&quot;</span>: toes,
+        <span class="s">&quot;toe_z&quot;</span>: toe_z,
+        <span class="s">&quot;posts&quot;</span>: len(posts),
+        <span class="s">&quot;stretchers&quot;</span>: len(stretchers),
+        <span class="s">&quot;st_gap&quot;</span>: st_gap,
+        <span class="s">&quot;slat_gap&quot;</span>: slat_gap,
+        <span class="s">&quot;seat_x&quot;</span>: seat_x,
+        <span class="s">&quot;slats&quot;</span>: len(slats),
+    }
+
+
 <span class="k">def</span> setup_bake_image(obj, target_mat, size=BAKE_RES):
     <span class="k">if</span> <span class="k">not</span> obj.data.uv_layers:
         <span class="k">return</span> <span class="k">None</span>, <span class="k">None</span>
@@ -765,15 +1095,42 @@ <h2>Source</h2>
     )
 
 
-<span class="k">def</span> check(skip_decimate):
+<span class="k">def</span> check(
+    skip_decimate,
+    lift_z=<span class="k">False</span>,
+    stray_vert=<span class="k">False</span>,
+    float_stretcher=<span class="k">False</span>,
+    gap_slats=<span class="k">False</span>,
+    short_feet=<span class="k">False</span>,
+    narrow_seat=<span class="k">False</span>,
+):
     bpy.ops.wm.read_factory_settings(use_empty=<span class="k">True</span>)
-    low = build_bench_mesh(<span class="s">&quot;BenchLow&quot;</span>, bevel_offset=<span class="n">0.005</span>, bevel_segments=<span class="n">2</span>)
-    high = build_bench_mesh(<span class="s">&quot;BenchHigh&quot;</span>, bevel_offset=<span class="n">0.005</span>, bevel_segments=<span class="n">4</span>)
-    wood = principled(<span class="s">&quot;BenchWood&quot;</span>, (<span class="n">0.40</span>, <span class="n">0.20</span>, <span class="n">0.07</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.58</span>)
-    metal = principled(<span class="s">&quot;BenchIron&quot;</span>, (<span class="n">0.09</span>, <span class="n">0.095</span>, <span class="n">0.11</span>, <span class="n">1.0</span>), <span class="n">1.0</span>, <span class="n">0.28</span>)
+    kw = dict(
+        float_stretcher=float_stretcher,
+        gap_slats=gap_slats,
+        short_feet=short_feet,
+        narrow_seat=narrow_seat,
+    )
+    low = build_bench_mesh(<span class="s">&quot;BenchLow&quot;</span>, bevel_offset=<span class="n">0.004</span>, bevel_segments=<span class="n">2</span>, **kw)
+    high = build_bench_mesh(<span class="s">&quot;BenchHigh&quot;</span>, bevel_offset=<span class="n">0.004</span>, bevel_segments=<span class="n">4</span>, **kw)
+    wood = principled(
+        <span class="s">&quot;BenchWood&quot;</span>, (<span class="n">0.40</span>, <span class="n">0.20</span>, <span class="n">0.07</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.58</span>,
+        noise_scale=<span class="n">18.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;BenchIron&quot;</span>, (<span class="n">0.09</span>, <span class="n">0.095</span>, <span class="n">0.11</span>, <span class="n">1.0</span>), <span class="n">1.0</span>, <span class="n">0.32</span>,
+        noise_scale=<span class="n">22.0</span>, wear=(<span class="n">0.16</span>, <span class="n">0.14</span>, <span class="n">0.10</span>, <span class="n">1.0</span>),
+    )
     assign_slots(low, wood, metal)
     assign_slots(high, wood, metal)
 
+    <span class="k">if</span> stray_vert:
+        add_stray_vert(low.data)
+    <span class="k">if</span> lift_z:
+        <span class="k">for</span> v <span class="k">in</span> low.data.vertices:
+            v.co.z += LIFT_Z
+        low.data.update()
+
     <span class="k">if</span> low.data <span class="k">is</span> <span class="k">None</span> <span class="k">or</span> len(low.data.polygons) &lt; <span class="n">6</span>:
         <span class="k">return</span> fail(<span class="s">&quot;bench 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>
 
@@ -804,7 +1161,9 @@ <h2>Source</h2>
     r1 = lod1_tris / base_tris <span class="k">if</span> base_tris <span class="k">else</span> <span class="n">0.0</span>
     r2 = lod2_tris / base_tris <span class="k">if</span> base_tris <span class="k">else</span> <span class="n">0.0</span>
 
-    collider_src = build_bench_mesh(<span class="s">&quot;BenchColSrc&quot;</span>, bevel_offset=<span class="n">0.0</span>, bevel_segments=<span class="n">1</span>)
+    collider_src = build_bench_mesh(
+        <span class="s">&quot;BenchColSrc&quot;</span>, bevel_offset=<span class="n">0.0</span>, bevel_segments=<span class="n">1</span>, **kw
+    )
     collider = convex_hull_collider(collider_src, <span class="s">&quot;BenchCollider&quot;</span>)
     bpy.data.objects.remove(collider_src, do_unlink=<span class="k">True</span>)
     col_tris = triangle_count(collider.data)
@@ -835,6 +1194,20 @@ <h2>Source</h2>
         <span class="s">f&quot;</span><span class="s">measured collider_tris=</span>{col_tris}<span class="s"> bake=</span>{bake_result}<span class="s"> </span><span class="s">&quot;</span>
         <span class="s">f&quot;</span><span class="s">bake_has_data=</span>{img.has_data}<span class="s"> export_bytes=</span>{export_size}<span class="s">&quot;</span>
     )
+    hyg = hygiene_audit(low.data)
+    zf = zfight_pairs(low.data)
+    jnt = joint_audit(low.data)
+    print(
+        <span class="s">f&quot;</span><span class="s">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 toes=</span>{jnt[<span class="s">&#x27;toes&#x27;</span>]}<span class="s"> toe_z=</span>{jnt[<span class="s">&#x27;toe_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">posts=</span>{jnt[<span class="s">&#x27;posts&#x27;</span>]}<span class="s"> stretchers=</span>{jnt[<span class="s">&#x27;stretchers&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">st_gap=</span>{jnt[<span class="s">&#x27;st_gap&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> slat_gap=</span>{jnt[<span class="s">&#x27;slat_gap&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">seat_x=</span>{jnt[<span class="s">&#x27;seat_x&#x27;</span>]:<span class="s">.4f</span>}<span class="s"> slats=</span>{jnt[<span class="s">&#x27;slats&#x27;</span>]}<span class="s">&quot;</span>
+    )
 
     <span class="k">if</span> <span class="k">not</span> (BASE_TRIS_MIN &lt;= base_tris &lt;= BASE_TRIS_MAX):
         <span class="k">return</span> fail(
@@ -866,6 +1239,16 @@ <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> abs(jnt[<span class="s">&quot;seat_x&quot;</span>] - SEAT_SPAN) &gt; SEAT_SPAN_TOL:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">seat span </span>{jnt[<span class="s">&#x27;seat_x&#x27;</span>]:<span class="s">.4f</span>}<span class="s"> off </span>{SEAT_SPAN}<span class="s">&quot;</span>,
+            <span class="n">19</span>,
+        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+    <span class="k">if</span> bb[<span class="n">2</span>] &gt; ZMIN_EPS <span class="k">or</span> jnt[<span class="s">&quot;toes&quot;</span>] != TOE_COUNT <span class="k">or</span> jnt[<span class="s">&quot;toe_z&quot;</span>] &gt; TOE_ZMIN_MAX:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">grounded zmin=</span>{bb[<span class="n">2</span>]:<span class="s">.5f</span>}<span class="s"> toes=</span>{jnt[<span class="s">&#x27;toes&#x27;</span>]}<span class="s"> toe_z=</span>{jnt[<span class="s">&#x27;toe_z&#x27;</span>]:<span class="s">.5f</span>}<span class="s">&quot;</span>,
+            <span class="n">16</span>,
+        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
     <span class="k">if</span> (
         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
@@ -899,6 +1282,26 @@ <h2>Source</h2>
         ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
     <span class="k">if</span> export_size &lt;= <span class="n">0</span>:
         <span class="k">return</span> fail(<span class="s">&quot;export file missing or empty&quot;</span>, <span class="n">13</span>), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+    <span class="k">if</span> (
+        hyg[<span class="s">&quot;loose_v&quot;</span>] <span class="k">or</span> hyg[<span class="s">&quot;loose_e&quot;</span>] <span class="k">or</span> hyg[<span class="s">&quot;nonman&quot;</span>] <span class="k">or</span> hyg[<span class="s">&quot;zero_area&quot;</span>]
+        <span class="k">or</span> hyg[<span class="s">&quot;doubles&quot;</span>] <span class="k">or</span> hyg[<span class="s">&quot;ngons&quot;</span>] <span class="k">or</span> zf
+    ):
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">hygiene loose_v=</span>{hyg[<span class="s">&#x27;loose_v&#x27;</span>]}<span class="s"> loose_e=</span>{hyg[<span class="s">&#x27;loose_e&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">f&quot;</span><span class="s">nonman=</span>{hyg[<span class="s">&#x27;nonman&#x27;</span>]}<span class="s"> zero_area=</span>{hyg[<span class="s">&#x27;zero_area&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">f&quot;</span><span class="s">doubles=</span>{hyg[<span class="s">&#x27;doubles&#x27;</span>]}<span class="s"> ngons=</span>{hyg[<span class="s">&#x27;ngons&#x27;</span>]}<span class="s"> zfight=</span>{zf}<span class="s">&quot;</span>,
+            <span class="n">15</span>,
+        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+    <span class="k">if</span> jnt[<span class="s">&quot;stretchers&quot;</span>] &lt; <span class="n">2</span> <span class="k">or</span> jnt[<span class="s">&quot;st_gap&quot;</span>] &gt; STRETCHER_GAP_MAX:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">stretcher gap </span>{jnt[<span class="s">&#x27;st_gap&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> stretchers=</span>{jnt[<span class="s">&#x27;stretchers&#x27;</span>]}<span class="s">&quot;</span>,
+            <span class="n">17</span>,
+        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+    <span class="k">if</span> jnt[<span class="s">&quot;slats&quot;</span>] &lt; <span class="n">4</span> <span class="k">or</span> jnt[<span class="s">&quot;slat_gap&quot;</span>] &gt; SLAT_GAP_MAX:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">slat gap </span>{jnt[<span class="s">&#x27;slat_gap&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> slats=</span>{jnt[<span class="s">&#x27;slats&#x27;</span>]}<span class="s">&quot;</span>,
+            <span class="n">18</span>,
+        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
     <span class="k">return</span> <span class="n">0</span>, low, high, wood, tex, collider
 
 
@@ -966,10 +1369,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.95</span>, -<span class="n">2.55</span>, <span class="n">1.22</span>)
+    cam.location = (<span class="n">2.22</span>, -<span class="n">2.90</span>, <span class="n">1.34</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.40</span>)
+    aim.location = (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.42</span>)
     scene.collection.objects.link(aim)
     con = cam.constraints.new(<span class="s">&quot;TRACK_TO&quot;</span>)
     con.target = aim
@@ -1012,14 +1415,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-feet&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--float-stretcher&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--gap-slats&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--narrow-seat&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
     args = p.parse_args(argv)
 
-    code, low, _high, wood, tex, _col = check(args.skip_decimate)
+    code, low, _high, wood, tex, _col = check(
+        args.skip_decimate,
+        lift_z=args.lift_z,
+        stray_vert=args.stray_vert,
+        float_stretcher=args.float_stretcher,
+        gap_slats=args.gap_slats,
+        short_feet=args.short_feet,
+        narrow_seat=args.narrow_seat,
+    )
     <span class="k">if</span> code:
         <span class="k">return</span> code
     <span class="k">if</span> args.output:
diff --git a/docs/gallery/terrain-scatter/index.html b/docs/gallery/terrain-scatter/index.html
index 827bb59..317d0c0 100644
--- a/docs/gallery/terrain-scatter/index.html
+++ b/docs/gallery/terrain-scatter/index.html
@@ -4,18 +4,18 @@
   <meta charset="utf-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1" />
   <title>terrain-scatter — Examples — Blender Developer Tools</title>
-  <meta name="description" content="A Geometry Nodes hill tile with masonry scatter through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
+  <meta name="description" content="A Geometry Nodes hill tile with seated icosphere scatter 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/terrain-scatter/" />
   <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="terrain-scatter — Examples — Blender Developer Tools" />
-  <meta property="og:description" content="A Geometry Nodes hill tile with masonry scatter through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
+  <meta property="og:description" content="A Geometry Nodes hill tile with seated icosphere scatter 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/terrain-scatter/" />
   <meta property="og:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/terrain-scatter-hero.webp" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="terrain-scatter — Examples — Blender Developer Tools" />
-  <meta name="twitter:description" content="A Geometry Nodes hill tile with masonry scatter through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
+  <meta name="twitter:description" content="A Geometry Nodes hill tile with seated icosphere scatter 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/terrain-scatter-hero.webp" />
   <style>
     /* fonts are deployed by the landing build (docs/fonts/) */
@@ -246,35 +246,48 @@
   </div>
   <header class="hero">
     <h1>terrain-scatter</h1>
-    <p>A Geometry Nodes hill tile with masonry scatter through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.</p>
+    <p>A Geometry Nodes hill tile with seated icosphere scatter 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 terrain-scatter render">
       <img src="../assets/terrain-scatter-hero.webp" alt="terrain-scatter 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: 1194 tris, two materials with 486 stone faces, UVs in 0..1 with zero AABB overlap, outer AABB 1.800×1.800×0.655 m, LOD ratios in band, convex collider 52 tris, non-empty glTF. --skip-decimate exits 9 on the LOD1 ratio budget.</div>
+    <div class="callout"><span class="tag">witnesses</span> Recomputed: 1758 tris, two materials with 720 stone faces, UVs in 0..1 with zero AABB overlap, outer AABB 1.800×1.800×0.552 m, grounded zmin, 9 stones of ≥80 faces seated on sampled dirt Z (offset −35 mm, floor zmin 0.113 m), LOD ratios in band, convex collider 81 tris, hygiene zero, non-empty glTF. --skip-decimate exits 9; --stray-vert 15; --lift-z 16; --poke-rock 17; --float-rocks 18; --box-rocks 19.</div>
     <div class="runline">
       <pre id="runCmd">blender --background --python showcase/terrain-scatter/terrain_scatter.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. Geometry Nodes sine-hill Mesh Grid with an Index-jittered Instance-on-Points scatter, realized cubes replaced by bevelled masonry, 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. Geometry Nodes sine-hill Mesh Grid with an Index-jittered Instance-on-Points scatter, realized cubes replaced by closed-form displaced icospheres seated on sampled dirt Z, then the shipped pipeline: unique-cell UVs, Cycles high-to-low normal bake, LOD chain, convex collider, Unity glTF export.</p>
+<p>GN still builds the hill and the instance grid. After realize+slabify, cube islands are deleted and each centroid is reseated: stone <code>zmin</code> equals sampled dirt Z minus a named bite, then verts clamp above the slab floor. That is why rocks sit on the hill instead of punching through the slab as bevelled crates.</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>geometry-nodes-python</code>, <code>mesh-editing-and-bmesh</code>, <code>bake-high-to-low</code>, <code>depsgraph-and-evaluated-data</code>, <code>engine-export-presets</code>, and snippets <code>bake_normal_high_to_low.py</code>, <code>setup_bake_target_image.py</code>, <code>lod_chain.py</code> / <code>decimate_to_budget.py</code>, <code>convex_hull_collider.py</code>, <code>export_preset_unity.py</code> (helpers copied, not imported as a package).</p>
+<p><strong>Composes</strong> skills <code>geometry-nodes-python</code>, <code>mesh-editing-and-bmesh</code>, <code>bake-high-to-low</code>, <code>depsgraph-and-evaluated-data</code>, <code>engine-export-presets</code>, and snippets <code>bake_normal_high_to_low.py</code>, <code>setup_bake_target_image.py</code>, <code>lod_chain.py</code> / <code>decimate_to_budget.py</code>, <code>convex_hull_collider.py</code>, <code>export_preset_unity.py</code> (helpers copied, not imported as a package). Hygiene combinatorics match <code>examples/mesh-hygiene-audit</code> (copied, not imported).</p>
+<p>Intended size: 1.80 m square hill tile, ~0.16 m sine amplitude, nine seated stones; outer AABB 1.800 × 1.800 × 0.552 m.</p>
 <h2>Budgets</h2>
 <p>Declared as named constants; every gate <strong>recomputes</strong> from the mesh, materials, UVs, evaluated LOD, collider, or export file.</p>
-<p>| Axis | Declared | Measured (4.5.11 / 5.1.2 / 5.2.1) | | --- | --- | --- | | Base triangles | 1150–1250 | 1194 / 1194 / 1194 | | LOD1 ratio | 0.32–0.62 of base | 0.4992 / 0.4992 / 0.4992 | | LOD2 ratio | 0.10–0.35 of base | 0.2194 / 0.2194 / 0.2194 | | Materials | exactly 2 distinct, ≥24 stone faces | 2 slots, 486 stone | | UVs | in <code>0..1</code>, AABB overlap ≤ 1e-5 | in range, overlap 0 | | Outer AABB | (1.800, 1.800, 0.655) m ± 0.01 | (1.8000, 1.8000, 0.6554), zmin 0 | | Collider tris | ≤ 80 | 52 | | Export | written, size &gt; 0 | 90704 / 90704 / 90696 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 may differ 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 | 1400–2800 | 1758 / 1758 / 1758 | | LOD1 ratio | 0.32–0.62 of base | 0.4994 / 0.4994 / 0.4994 | | LOD2 ratio | 0.10–0.35 of base | 0.2196 / 0.2196 / 0.2196 | | Materials | exactly 2 distinct, ≥24 stone faces | 2 slots, 720 stone | | UVs | in <code>0..1</code>, AABB overlap ≤ 1e-5 | in range, overlap 0 | | Outer AABB | (1.800, 1.800, 0.552) m ± 0.015 | (1.8000, 1.8000, 0.5523), zmin 0 | | Collider tris | ≤ 120 | 81 | | Export | written, size &gt; 0 | 158156 / 158156 / 158140 bytes |</p>
+<p>Base triangles rose from <strong>1194 to 1758</strong> in the quality pass: 9-vert hill became a 21-vert grid, and bevelled cubes became subdiv-2 icospheres. Outer Z dropped from 0.655 m (crate corners swinging through the slab) to 0.552 m of seated stone on the hill.</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 matched 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. 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 | | Stone shells | 9 | 9 | | Per-stone faces | ≥ 40 | 80 | | Stone floor <code>zmin</code> | ≥ 0.012 m | 0.11334 | | Seat offset (<code>zmin</code> − dirt Z) | ≤ 0.02 m | −0.03500 |</p>
+<h3>Falsifiers</h3>
+<p>Each violates one named budget. All were run on 4.5.11, 5.1.2 and 5.2.1 and returned the same code on each.</p>
+<p>| Flag | Budget violated | Exit | | --- | --- | --- | | <code>--skip-decimate</code> | LOD1 ratio band | 9 | | <code>--stray-vert</code> | loose vertex count is 0 | 15 | | <code>--lift-z</code> | bounding box <code>zmin</code> is 0 | 16 | | <code>--poke-rock</code> | stone floor <code>zmin</code> | 17 | | <code>--float-rocks</code> | seat offset vs sampled dirt Z | 18 | | <code>--box-rocks</code> | per-stone face floor | 19 |</p>
 <h2>Run</h2>
 <pre><code>blender --background --python terrain_scatter.py --
 blender --background --python terrain_scatter.py -- --skip-decimate
+blender --background --python terrain_scatter.py -- --stray-vert
+blender --background --python terrain_scatter.py -- --lift-z
+blender --background --python terrain_scatter.py -- --poke-rock
+blender --background --python terrain_scatter.py -- --float-rocks
+blender --background --python terrain_scatter.py -- --box-rocks
 blender --background --python terrain_scatter.py -- --output terrain.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 stone 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 stone faces missing | | 6 | UVs outside 0..1 | | 7 | UV AABB overlap above tolerance | | 8 | World AABB off declared outer size | | 9 | LOD ratio band (<code>--skip-decimate</code> lands here) | | 10 | Framing gate (render path only) | | 11 | Collider triangle count above ceiling | | 12 | Bake did not finish or image has no data | | 13 | Export file missing or empty | | 14 | <code>--output</code> produced no file | | 15 | Hygiene (<code>--stray-vert</code> lands here) | | 16 | Grounded zmin (<code>--lift-z</code>) | | 17 | Stone floor poke (<code>--poke-rock</code>) | | 18 | Float above host (<code>--float-rocks</code>) | | 19 | Stone shell faces (<code>--box-rocks</code>) |</p>
     </section>
     <section class="detail-section src">
       <h2>Source</h2>
@@ -285,19 +298,23 @@ <h2>Source</h2>
       <pre><span class="s">&quot;&quot;&quot;Game-ready GN terrain scatter — a showcase piece, not an example.
 
 Asserts budget conformance of a Geometry Nodes hill grid with instanced
-masonry rocks after composing shipped pipeline pieces: GN construction,
+rocks after composing shipped pipeline pieces: GN construction,
 UVs, two materials, high-to-low normal bake, LOD chain, convex collider,
 Unity glTF export.
 
+GN still builds the sine hill and the Index-jittered instance grid.
+Realized cubes are replaced with closed-form displaced icospheres seated
+on sampled dirt Z, then clamped above the slab floor.
+
 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`` LOD, ``--stray-vert`` hygiene, ``--lift-z``
+zmin, ``--poke-rock`` stone floor, ``--float-rocks`` seat, ``--box-rocks``
+stone shell faces.
 
 No RNG. Hills are a closed-form sine product; scatter is an Index-jittered
-instance grid. Realized cubes are replaced with bevelled lumped boxes
-(campfire/well masonry, not icospheres). DECIMATE COLLAPSE triangle
-counts are not byte-identical across Blender versions — the LOD gate is
-a ratio band, not an exact count.
+instance grid. DECIMATE COLLAPSE triangle counts are not byte-identical
+across Blender versions — the LOD gate is a ratio band, not an exact count.
 
     blender --background --python terrain_scatter.py --
     blender --background --python terrain_scatter.py -- --skip-decimate
@@ -328,11 +345,14 @@ <h2>Source</h2>
 ROCK_GRID = <span class="n">3</span>
 ROCK_SPAN = <span class="n">1.15</span>
 SLAB_LIFT = <span class="n">0.10</span>
-
-BBOX_TOL = <span class="n">0.01</span>
-OUTER_SIZE = (<span class="n">1.800</span>, <span class="n">1.800</span>, <span class="n">0.655</span>)
-BASE_TRIS_MIN = <span class="n">1150</span>
-BASE_TRIS_MAX = <span class="n">1250</span>
+ROCK_BITE = <span class="n">0.035</span>
+ROCK_ZMIN = <span class="n">0.012</span>
+N_ROCKS = <span class="n">9</span>
+
+BBOX_TOL = <span class="n">0.015</span>
+OUTER_SIZE = (<span class="n">1.800</span>, <span class="n">1.800</span>, <span class="n">0.552</span>)
+BASE_TRIS_MIN = <span class="n">1400</span>
+BASE_TRIS_MAX = <span class="n">2800</span>
 LOD1_RATIO_MIN = <span class="n">0.32</span>
 LOD1_RATIO_MAX = <span class="n">0.62</span>
 LOD2_RATIO_MIN = <span class="n">0.10</span>
@@ -342,10 +362,20 @@ <h2>Source</h2>
 MATERIAL_COUNT = <span class="n">2</span>
 UV_EPS = <span class="n">1e-4</span>
 UV_OVERLAP_MAX = <span class="n">1e-5</span>
-COLLIDER_TRIS_MAX = <span class="n">80</span>
+COLLIDER_TRIS_MAX = <span class="n">120</span>
 BAKE_RES = <span class="n">256</span>
 CAGE_EXTRUSION = <span class="n">0.08</span>
 STONE_FACES_MIN = <span class="n">24</span>
+STONE_SHELL_FACES_MIN = <span class="n">40</span>
+ZMIN_EPS = <span class="n">1e-4</span>
+DOUBLES_EPS = <span class="n">1e-5</span>
+AREA_EPS = <span class="n">1e-10</span>
+ZFIGHT_EPS = <span class="n">1e-4</span>
+ZFIGHT_COS = <span class="n">0.998</span>
+ROCK_SEAT_MAX = <span class="n">0.02</span>
+FLOAT_LIFT = <span class="n">0.12</span>
+POKE_BITE = <span class="n">0.22</span>
+LIFT_Z = <span class="n">0.05</span>
 
 DIRT_IDX = <span class="n">0</span>
 STONE_IDX = <span class="n">1</span>
@@ -517,7 +547,7 @@ <h2>Source</h2>
     tree.links.new(jx.outputs[<span class="n">0</span>], jxs.inputs[<span class="n">0</span>])
     jxm = tree.nodes.new(<span class="s">&quot;ShaderNodeMath&quot;</span>)
     jxm.operation = <span class="s">&quot;MULTIPLY&quot;</span>
-    jxm.inputs[<span class="n">1</span>].default_value = <span class="n">0.09</span>
+    jxm.inputs[<span class="n">1</span>].default_value = <span class="n">0.22</span>
     tree.links.new(jxs.outputs[<span class="n">0</span>], jxm.inputs[<span class="n">0</span>])
     jy = tree.nodes.new(<span class="s">&quot;ShaderNodeMath&quot;</span>)
     jy.operation = <span class="s">&quot;MULTIPLY&quot;</span>
@@ -528,7 +558,7 @@ <h2>Source</h2>
     tree.links.new(jy.outputs[<span class="n">0</span>], jyc.inputs[<span class="n">0</span>])
     jym = tree.nodes.new(<span class="s">&quot;ShaderNodeMath&quot;</span>)
     jym.operation = <span class="s">&quot;MULTIPLY&quot;</span>
-    jym.inputs[<span class="n">1</span>].default_value = <span class="n">0.09</span>
+    jym.inputs[<span class="n">1</span>].default_value = <span class="n">0.22</span>
     tree.links.new(jyc.outputs[<span class="n">0</span>], jym.inputs[<span class="n">0</span>])
     extra = tree.nodes.new(<span class="s">&quot;ShaderNodeMath&quot;</span>)
     extra.operation = <span class="s">&quot;ADD&quot;</span>
@@ -640,7 +670,64 @@ <h2>Source</h2>
             f.material_index = DIRT_IDX
 
 
-<span class="k">def</span> masonry_from_cubes(bm, lump, bevel_offset, bevel_segments):
+<span class="k">def</span> nearest_dirt_z(bm, x, y):
+    best_z = <span class="k">None</span>
+    best_d = <span class="n">1e9</span>
+    <span class="k">for</span> v <span class="k">in</span> bm.verts:
+        <span class="k">if</span> <span class="k">not</span> v.link_faces:
+            <span class="k">continue</span>
+        <span class="k">if</span> <span class="k">not</span> any(f.material_index == DIRT_IDX <span class="k">for</span> f <span class="k">in</span> v.link_faces):
+            <span class="k">continue</span>
+        dx = v.co.x - x
+        dy = v.co.y - y
+        d = dx * dx + dy * dy
+        <span class="k">if</span> d &lt; best_d:
+            best_d = d
+            best_z = v.co.z
+    <span class="k">return</span> <span class="n">0.0</span> <span class="k">if</span> best_z <span class="k">is</span> <span class="k">None</span> <span class="k">else</span> best_z
+
+
+<span class="k">def</span> add_seated_stone(bm, cx, cy, dirt_z, box_rocks, poke, float_up):
+    sx = <span class="n">0.11</span> + <span class="n">0.025</span> * math.sin(cx * <span class="n">8.1</span>)
+    sy = <span class="n">0.10</span> + <span class="n">0.022</span> * math.cos(cy * <span class="n">6.4</span>)
+    sz = <span class="n">0.075</span> + <span class="n">0.020</span> * math.sin(cx * <span class="n">4.2</span> + cy * <span class="n">3.1</span>)
+    bite = POKE_BITE <span class="k">if</span> poke <span class="k">else</span> ROCK_BITE
+    seat = dirt_z + FLOAT_LIFT <span class="k">if</span> float_up <span class="k">else</span> dirt_z - bite
+    rot = Euler(
+        (
+            <span class="n">0.22</span> * math.sin(cx * <span class="n">3.1</span>),
+            <span class="n">0.18</span> * math.cos(cy * <span class="n">2.7</span>),
+            cx * <span class="n">2.4</span> + cy * <span class="n">1.6</span>,
+        )
+    ).to_matrix()
+    <span class="k">if</span> box_rocks:
+        verts = add_box(bm, (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>), (sx * <span class="n">2.0</span>, sy * <span class="n">2.0</span>, sz * <span class="n">2.0</span>), STONE_IDX)
+        <span class="k">for</span> v <span class="k">in</span> verts:
+            v.co = rot @ v.co
+    <span class="k">else</span>:
+        geo = bmesh.ops.create_icosphere(bm, subdivisions=<span class="n">2</span>, radius=<span class="n">1.0</span>)
+        verts = geo[<span class="s">&quot;verts&quot;</span>]
+        <span class="k">for</span> v <span class="k">in</span> verts:
+            p = Vector((v.co.x * sx, v.co.y * sy, v.co.z * sz))
+            <span class="k">if</span> p.length &gt; <span class="n">1e-8</span>:
+                bump = <span class="n">0.016</span> * math.sin(p.x * <span class="n">26.0</span> + cx * <span class="n">5.0</span>) * math.cos(
+                    p.y * <span class="n">21.0</span> + cy * <span class="n">4.0</span>
+                )
+                p += p.normalized() * bump
+            v.co = rot @ p
+        <span class="k">for</span> f <span class="k">in</span> {face <span class="k">for</span> v <span class="k">in</span> verts <span class="k">for</span> face <span class="k">in</span> v.link_faces}:
+            f.material_index = STONE_IDX
+    zmin = min(v.co.z <span class="k">for</span> v <span class="k">in</span> verts)
+    dz = seat - zmin
+    <span class="k">for</span> v <span class="k">in</span> verts:
+        v.co.x += cx
+        v.co.y += cy
+        v.co.z += dz
+        <span class="k">if</span> <span class="k">not</span> poke <span class="k">and</span> v.co.z &lt; ROCK_ZMIN:
+            v.co.z = ROCK_ZMIN
+
+
+<span class="k">def</span> masonry_from_cubes(bm, box_rocks=<span class="k">False</span>, poke=<span class="k">False</span>, float_up=<span class="k">False</span>):
     stone_faces = [f <span class="k">for</span> f <span class="k">in</span> bm.faces <span class="k">if</span> f.material_index == STONE_IDX]
     visited = set()
     islands = []
@@ -666,19 +753,9 @@ <h2>Source</h2>
         verts = {v <span class="k">for</span> f <span class="k">in</span> island <span class="k">for</span> v <span class="k">in</span> f.verts}
         xs = [v.co.x <span class="k">for</span> v <span class="k">in</span> verts]
         ys = [v.co.y <span class="k">for</span> v <span class="k">in</span> verts]
-        zs = [v.co.z <span class="k">for</span> v <span class="k">in</span> verts]
         cx = <span class="n">0.5</span> * (min(xs) + max(xs))
         cy = <span class="n">0.5</span> * (min(ys) + max(ys))
-        cz = <span class="n">0.5</span> * (min(zs) + max(zs))
-        z0 = min(zs)
-        sx = <span class="n">0.17</span> + <span class="n">0.04</span> * math.sin(cx * <span class="n">8.1</span>)
-        sy = <span class="n">0.15</span> + <span class="n">0.03</span> * math.cos(cy * <span class="n">6.4</span>)
-        sz = <span class="n">0.20</span> + <span class="n">0.05</span> * math.sin(cx * <span class="n">4.2</span> + cy * <span class="n">3.1</span>)
-        ex = <span class="n">0.38</span> * math.sin(cx * <span class="n">5.1</span>)
-        ey = <span class="n">0.30</span> * math.cos(cy * <span class="n">4.3</span>)
-        ez = cx * <span class="n">3.7</span> + cy * <span class="n">2.1</span>
-        cz = z0 + sz * <span class="n">0.30</span>
-        specs.append((cx, cy, cz, sx, sy, sz, ex, ey, ez))
+        specs.append((cx, cy))
 
     <span class="k">if</span> stone_faces:
         bmesh.ops.delete(bm, geom=stone_faces, context=<span class="s">&quot;FACES&quot;</span>)
@@ -686,31 +763,22 @@ <h2>Source</h2>
         <span class="k">if</span> loose:
             bmesh.ops.delete(bm, geom=loose, context=<span class="s">&quot;VERTS&quot;</span>)
 
-    <span class="k">for</span> cx, cy, cz, sx, sy, sz, ex, ey, ez <span class="k">in</span> specs:
-        verts = add_box(
-            bm,
-            (cx, cy, cz),
-            (sx, sy, sz),
-            STONE_IDX,
-            euler=(ex, ey, ez),
-        )
-        <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> verts <span class="k">for</span> e <span class="k">in</span> v.link_edges})
-            <span class="k">if</span> edges:
-                ret = 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="k">for</span> f <span class="k">in</span> ret.get(<span class="s">&quot;faces&quot;</span>) <span class="k">or</span> []:
-                    f.material_index = STONE_IDX
-
-
-<span class="k">def</span> build_terrain_mesh(name, grid_verts, lump, bevel_offset, bevel_segments, dirt, stone):
+    bm.verts.ensure_lookup_table()
+    bm.faces.ensure_lookup_table()
+    <span class="k">for</span> cx, cy <span class="k">in</span> specs:
+        dirt_z = nearest_dirt_z(bm, cx, cy)
+        add_seated_stone(bm, cx, cy, dirt_z, box_rocks, poke, float_up)
+
+
+<span class="k">def</span> build_terrain_mesh(
+    name,
+    grid_verts,
+    dirt,
+    stone,
+    box_rocks=<span class="k">False</span>,
+    poke=<span class="k">False</span>,
+    float_up=<span class="k">False</span>,
+):
     carrier = bpy.data.meshes.new(name + <span class="s">&quot;Carrier&quot;</span>)
     carrier.vertices.add(<span class="n">1</span>)
     obj = bpy.data.objects.new(name + <span class="s">&quot;GN&quot;</span>, carrier)
@@ -730,7 +798,7 @@ <h2>Source</h2>
         slabify(bm, floor_z=<span class="n">0.0</span>)
         bm.verts.ensure_lookup_table()
         bm.faces.ensure_lookup_table()
-        masonry_from_cubes(bm, lump, bevel_offset, bevel_segments)
+        masonry_from_cubes(bm, box_rocks=box_rocks, poke=poke, float_up=float_up)
         xs = [v.co.x <span class="k">for</span> v <span class="k">in</span> bm.verts]
         ys = [v.co.y <span class="k">for</span> v <span class="k">in</span> bm.verts]
         zs = [v.co.z <span class="k">for</span> v <span class="k">in</span> bm.verts]
@@ -743,15 +811,18 @@ <h2>Source</h2>
             v.co.z -= zmin
             <span class="k">if</span> v.co.z &lt; <span class="n">0.0</span>:
                 v.co.z = <span class="n">0.0</span>
+        ngons = [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> ngons:
+            bmesh.ops.triangulate(bm, faces=ngons)
         pack_uvs(bm)
         bmesh.ops.recalc_face_normals(bm, faces=list(bm.faces))
         <span class="k">for</span> face <span class="k">in</span> bm.faces:
-            face.smooth = <span class="k">False</span>
+            face.smooth = face.material_index == STONE_IDX
         me = bpy.data.meshes.new(name)
         bm.to_mesh(me)
         me.update()
         <span class="k">for</span> poly <span class="k">in</span> me.polygons:
-            poly.use_smooth = <span class="k">False</span>
+            poly.use_smooth = poly.material_index == STONE_IDX
     <span class="k">finally</span>:
         bm.free()
     out = bpy.data.objects.new(name, me)
@@ -759,13 +830,25 @@ <h2>Source</h2>
     <span class="k">return</span> out
 
 
-<span class="k">def</span> principled(name, color, metallic, roughness):
+<span class="k">def</span> principled(name, color, metallic, roughness, noise_scale=<span class="n">0.0</span>, wear=<span class="k">None</span>):
     mat = bpy.data.materials.new(name)
     mat.use_nodes = <span class="k">True</span>
-    bsdf = mat.node_tree.nodes[<span class="s">&quot;Principled BSDF&quot;</span>]
+    nt = mat.node_tree
+    bsdf = nt.nodes[<span class="s">&quot;Principled BSDF&quot;</span>]
     bsdf.inputs[<span class="s">&quot;Base Color&quot;</span>].default_value = color
     bsdf.inputs[<span class="s">&quot;Metallic&quot;</span>].default_value = metallic
     bsdf.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = roughness
+    <span class="k">if</span> noise_scale &gt; <span class="n">0.0</span> <span class="k">and</span> wear <span class="k">is</span> <span class="k">not</span> <span class="k">None</span>:
+        tex = nt.nodes.new(<span class="s">&quot;ShaderNodeTexNoise&quot;</span>)
+        tex.inputs[<span class="s">&quot;Scale&quot;</span>].default_value = noise_scale
+        tex.inputs[<span class="s">&quot;Detail&quot;</span>].default_value = <span class="n">6.0</span>
+        mix = nt.nodes.new(<span class="s">&quot;ShaderNodeMix&quot;</span>)
+        mix.data_type = <span class="s">&quot;RGBA&quot;</span>
+        mix.inputs[<span class="s">&quot;A&quot;</span>].default_value = color
+        mix.inputs[<span class="s">&quot;B&quot;</span>].default_value = wear
+        fac = mix.inputs.get(<span class="s">&quot;Factor&quot;</span>) <span class="k">or</span> mix.inputs.get(<span class="s">&quot;Fac&quot;</span>)
+        nt.links.new(tex.outputs[<span class="s">&quot;Fac&quot;</span>], fac)
+        nt.links.new(mix.outputs[<span class="s">&quot;Result&quot;</span>], bsdf.inputs[<span class="s">&quot;Base Color&quot;</span>])
     <span class="k">return</span> mat
 
 
@@ -782,10 +865,11 @@ <h2>Source</h2>
 
 
 <span class="k">def</span> world_bbox(obj):
-    corners = [obj.matrix_world @ Vector(c) <span class="k">for</span> c <span class="k">in</span> obj.bound_box]
-    xs = [c.x <span class="k">for</span> c <span class="k">in</span> corners]
-    ys = [c.y <span class="k">for</span> c <span class="k">in</span> corners]
-    zs = [c.z <span class="k">for</span> c <span class="k">in</span> corners]
+    mat = obj.matrix_world
+    pts = [mat @ v.co <span class="k">for</span> v <span class="k">in</span> obj.data.vertices]
+    xs = [p.x <span class="k">for</span> p <span class="k">in</span> pts]
+    ys = [p.y <span class="k">for</span> p <span class="k">in</span> pts]
+    zs = [p.z <span class="k">for</span> p <span class="k">in</span> pts]
     <span class="k">return</span> (min(xs), min(ys), min(zs), max(xs), max(ys), max(zs))
 
 
@@ -900,15 +984,187 @@ <h2>Source</h2>
     )
 
 
-<span class="k">def</span> check(skip_decimate):
+<span class="k">def</span> face_area(me, poly):
+    vs = [me.vertices[i].co <span class="k">for</span> i <span class="k">in</span> poly.vertices]
+    <span class="k">if</span> len(vs) &lt; <span class="n">3</span>:
+        <span class="k">return</span> <span class="n">0.0</span>
+    v0 = vs[<span class="n">0</span>]
+    area = <span class="n">0.0</span>
+    <span class="k">for</span> i <span class="k">in</span> range(<span class="n">1</span>, len(vs) - <span class="n">1</span>):
+        area += (vs[i] - v0).cross(vs[i + <span class="n">1</span>] - v0).length * <span class="n">0.5</span>
+    <span class="k">return</span> area
+
+
+<span class="k">def</span> hygiene_audit(me):
+    nv, ne, nf = len(me.vertices), len(me.edges), len(me.polygons)
+    ngons = sum(<span class="n">1</span> <span class="k">for</span> p <span class="k">in</span> me.polygons <span class="k">if</span> len(p.vertices) &gt; <span class="n">4</span>)
+    zero_area = sum(<span class="n">1</span> <span class="k">for</span> p <span class="k">in</span> me.polygons <span class="k">if</span> face_area(me, p) &lt;= AREA_EPS)
+    bm = bmesh.new()
+    <span class="k">try</span>:
+        bm.from_mesh(me)
+        loose_v = sum(<span class="n">1</span> <span class="k">for</span> v <span class="k">in</span> bm.verts <span class="k">if</span> len(v.link_edges) == <span class="n">0</span>)
+        loose_e = sum(<span class="n">1</span> <span class="k">for</span> e <span class="k">in</span> bm.edges <span class="k">if</span> len(e.link_faces) == <span class="n">0</span>)
+        nonman = sum(<span class="n">1</span> <span class="k">for</span> e <span class="k">in</span> bm.edges <span class="k">if</span> <span class="k">not</span> e.is_manifold)
+        ret = bmesh.ops.find_doubles(bm, verts=list(bm.verts), dist=DOUBLES_EPS)
+        doubles = len(ret.get(<span class="s">&quot;targetmap&quot;</span>) <span class="k">or</span> {})
+    <span class="k">finally</span>:
+        bm.free()
+    <span class="k">return</span> {
+        <span class="s">&quot;nv&quot;</span>: nv, <span class="s">&quot;ne&quot;</span>: ne, <span class="s">&quot;nf&quot;</span>: nf, <span class="s">&quot;ngons&quot;</span>: ngons,
+        <span class="s">&quot;loose_v&quot;</span>: loose_v, <span class="s">&quot;loose_e&quot;</span>: loose_e, <span class="s">&quot;nonman&quot;</span>: nonman,
+        <span class="s">&quot;zero_area&quot;</span>: zero_area, <span class="s">&quot;doubles&quot;</span>: doubles, <span class="s">&quot;euler&quot;</span>: nv - ne + nf,
+    }
+
+
+<span class="k">def</span> zfight_pairs(me):
+    data = [
+        (p.center.copy(), p.normal.copy(), frozenset(p.vertices))
+        <span class="k">for</span> p <span class="k">in</span> me.polygons
+    ]
+    eps2 = ZFIGHT_EPS * ZFIGHT_EPS
+    count = <span class="n">0</span>
+    <span class="k">for</span> i <span class="k">in</span> range(len(data)):
+        ci, ni, vi = data[i]
+        <span class="k">for</span> j <span class="k">in</span> range(i + <span class="n">1</span>, len(data)):
+            cj, nj, vj = data[j]
+            <span class="k">if</span> (cj - ci).length_squared &gt; eps2:
+                <span class="k">continue</span>
+            <span class="k">if</span> abs(ni.dot(nj)) &lt;= ZFIGHT_COS:
+                <span class="k">continue</span>
+            <span class="k">if</span> vi &amp; vj:
+                <span class="k">continue</span>
+            count += <span class="n">1</span>
+    <span class="k">return</span> count
+
+
+<span class="k">def</span> shells(me):
+    neighbors = [[] <span class="k">for</span> _ <span class="k">in</span> range(len(me.vertices))]
+    <span class="k">for</span> edge <span class="k">in</span> me.edges:
+        a, b = edge.vertices
+        neighbors[a].append(b)
+        neighbors[b].append(a)
+    seen = [<span class="k">False</span>] * len(me.vertices)
+    groups = []
+    <span class="k">for</span> start <span class="k">in</span> range(len(me.vertices)):
+        <span class="k">if</span> seen[start]:
+            <span class="k">continue</span>
+        seen[start] = <span class="k">True</span>
+        stack = [start]
+        group = []
+        <span class="k">while</span> stack:
+            current = stack.pop()
+            group.append(current)
+            <span class="k">for</span> nxt <span class="k">in</span> neighbors[current]:
+                <span class="k">if</span> <span class="k">not</span> seen[nxt]:
+                    seen[nxt] = <span class="k">True</span>
+                    stack.append(nxt)
+        groups.append(group)
+    <span class="k">return</span> groups
+
+
+<span class="k">def</span> shell_aabb(me, group):
+    pts = [me.vertices[i].co <span class="k">for</span> i <span class="k">in</span> group]
+    <span class="k">return</span> (
+        min(p.x <span class="k">for</span> p <span class="k">in</span> pts), min(p.y <span class="k">for</span> p <span class="k">in</span> pts), min(p.z <span class="k">for</span> p <span class="k">in</span> pts),
+        max(p.x <span class="k">for</span> p <span class="k">in</span> pts), max(p.y <span class="k">for</span> p <span class="k">in</span> pts), max(p.z <span class="k">for</span> p <span class="k">in</span> pts),
+    )
+
+
+<span class="k">def</span> mat_of(me, group):
+    member = set(group)
+    <span class="k">for</span> poly <span class="k">in</span> me.polygons:
+        <span class="k">if</span> all(i <span class="k">in</span> member <span class="k">for</span> i <span class="k">in</span> poly.vertices):
+            <span class="k">return</span> poly.material_index
+    <span class="k">return</span> <span class="k">None</span>
+
+
+<span class="k">def</span> shell_faces(me, group):
+    member = set(group)
+    <span class="k">return</span> sum(<span class="n">1</span> <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">def</span> add_stray_vert(me):
+    bm = bmesh.new()
+    <span class="k">try</span>:
+        bm.from_mesh(me)
+        bm.verts.new((<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.55</span>))
+        bm.to_mesh(me)
+        me.update()
+    <span class="k">finally</span>:
+        bm.free()
+
+
+<span class="k">def</span> nearest_mesh_dirt_z(me, x, y, dirt_verts):
+    best_z = <span class="n">0.0</span>
+    best_d = <span class="n">1e9</span>
+    <span class="k">for</span> co <span class="k">in</span> dirt_verts:
+        d = (co.x - x) ** <span class="n">2</span> + (co.y - y) ** <span class="n">2</span>
+        <span class="k">if</span> d &lt; best_d:
+            best_d = d
+            best_z = co.z
+    <span class="k">return</span> best_z
+
+
+<span class="k">def</span> joint_audit(me):
+    groups = shells(me)
+    stones = []
+    dirt_verts = []
+    <span class="k">for</span> poly <span class="k">in</span> me.polygons:
+        <span class="k">if</span> poly.material_index != DIRT_IDX:
+            <span class="k">continue</span>
+        <span class="k">for</span> i <span class="k">in</span> poly.vertices:
+            dirt_verts.append(me.vertices[i].co)
+    <span class="k">for</span> g <span class="k">in</span> groups:
+        <span class="k">if</span> mat_of(me, g) != STONE_IDX:
+            <span class="k">continue</span>
+        a = shell_aabb(me, g)
+        nfaces = shell_faces(me, g)
+        cx = <span class="n">0.5</span> * (a[<span class="n">0</span>] + a[<span class="n">3</span>])
+        cy = <span class="n">0.5</span> * (a[<span class="n">1</span>] + a[<span class="n">4</span>])
+        dirt_z = nearest_mesh_dirt_z(me, cx, cy, dirt_verts)
+        stones.append((a[<span class="n">2</span>], nfaces, a[<span class="n">2</span>] - dirt_z))
+    n_stones = len(stones)
+    min_faces = min((s[<span class="n">1</span>] <span class="k">for</span> s <span class="k">in</span> stones), default=<span class="n">0</span>)
+    poke_z = min((s[<span class="n">0</span>] <span class="k">for</span> s <span class="k">in</span> stones), default=<span class="n">99.0</span>)
+    float_off = max((s[<span class="n">2</span>] <span class="k">for</span> s <span class="k">in</span> stones), default=<span class="n">0.0</span>)
+    <span class="k">return</span> {
+        <span class="s">&quot;n_stones&quot;</span>: n_stones,
+        <span class="s">&quot;min_faces&quot;</span>: min_faces,
+        <span class="s">&quot;poke_z&quot;</span>: poke_z,
+        <span class="s">&quot;float_off&quot;</span>: float_off,
+    }
+
+
+<span class="k">def</span> check(
+    skip_decimate,
+    lift_z=<span class="k">False</span>,
+    stray_vert=<span class="k">False</span>,
+    poke=<span class="k">False</span>,
+    float_up=<span class="k">False</span>,
+    box_rocks=<span class="k">False</span>,
+):
     bpy.ops.wm.read_factory_settings(use_empty=<span class="k">True</span>)
-    dirt = principled(<span class="s">&quot;TerrainDirt&quot;</span>, (<span class="n">0.30</span>, <span class="n">0.17</span>, <span class="n">0.07</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.90</span>)
-    stone = principled(<span class="s">&quot;TerrainStone&quot;</span>, (<span class="n">0.56</span>, <span class="n">0.53</span>, <span class="n">0.48</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.76</span>)
-    low = build_terrain_mesh(<span class="s">&quot;TerrainLow&quot;</span>, <span class="n">9</span>, <span class="n">0.10</span>, <span class="n">0.022</span>, <span class="n">2</span>, dirt, stone)
-    high = build_terrain_mesh(<span class="s">&quot;TerrainHigh&quot;</span>, <span class="n">13</span>, <span class="n">0.10</span>, <span class="n">0.022</span>, <span class="n">4</span>, dirt, stone)
+    dirt = principled(
+        <span class="s">&quot;TerrainDirt&quot;</span>, (<span class="n">0.30</span>, <span class="n">0.17</span>, <span class="n">0.07</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.90</span>,
+        noise_scale=<span class="n">14.0</span>, wear=(<span class="n">0.18</span>, <span class="n">0.10</span>, <span class="n">0.04</span>, <span class="n">1.0</span>),
+    )
+    stone = principled(
+        <span class="s">&quot;TerrainStone&quot;</span>, (<span class="n">0.56</span>, <span class="n">0.53</span>, <span class="n">0.48</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.76</span>,
+        noise_scale=<span class="n">20.0</span>, wear=(<span class="n">0.38</span>, <span class="n">0.35</span>, <span class="n">0.30</span>, <span class="n">1.0</span>),
+    )
+    kw = dict(box_rocks=box_rocks, poke=poke, float_up=float_up)
+    low = build_terrain_mesh(<span class="s">&quot;TerrainLow&quot;</span>, <span class="n">21</span>, dirt, stone, **kw)
+    high = build_terrain_mesh(<span class="s">&quot;TerrainHigh&quot;</span>, <span class="n">25</span>, dirt, stone, **kw)
     assign_slots(low, dirt, stone)
     assign_slots(high, dirt, stone)
 
+    <span class="k">if</span> stray_vert:
+        add_stray_vert(low.data)
+    <span class="k">if</span> lift_z:
+        <span class="k">for</span> v <span class="k">in</span> low.data.vertices:
+            v.co.z += LIFT_Z
+        low.data.update()
+
     <span class="k">if</span> low.data <span class="k">is</span> <span class="k">None</span> <span class="k">or</span> len(low.data.polygons) &lt; <span class="n">6</span>:
         <span class="k">return</span> fail(<span class="s">&quot;terrain 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>
 
@@ -940,7 +1196,7 @@ <h2>Source</h2>
     r2 = lod2_tris / base_tris <span class="k">if</span> base_tris <span class="k">else</span> <span class="n">0.0</span>
 
     collider_src = build_terrain_mesh(
-        <span class="s">&quot;TerrainColSrc&quot;</span>, <span class="n">9</span>, <span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">1</span>, dirt, stone
+        <span class="s">&quot;TerrainColSrc&quot;</span>, <span class="n">21</span>, dirt, stone, **kw
     )
     collider = convex_hull_collider(collider_src, <span class="s">&quot;TerrainCollider&quot;</span>)
     bpy.data.objects.remove(collider_src, do_unlink=<span class="k">True</span>)
@@ -972,7 +1228,24 @@ <h2>Source</h2>
         <span class="s">f&quot;</span><span class="s">measured collider_tris=</span>{col_tris}<span class="s"> bake=</span>{bake_result}<span class="s"> </span><span class="s">&quot;</span>
         <span class="s">f&quot;</span><span class="s">bake_has_data=</span>{img.has_data}<span class="s"> export_bytes=</span>{export_size}<span class="s">&quot;</span>
     )
+    hyg = hygiene_audit(low.data)
+    zf = zfight_pairs(low.data)
+    jnt = joint_audit(low.data)
+    print(
+        <span class="s">f&quot;</span><span class="s">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 stones=</span>{jnt[<span class="s">&#x27;n_stones&#x27;</span>]}<span class="s"> min_faces=</span>{jnt[<span class="s">&#x27;min_faces&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">poke_z=</span>{jnt[<span class="s">&#x27;poke_z&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> float_off=</span>{jnt[<span class="s">&#x27;float_off&#x27;</span>]:<span class="s">.5f</span>}<span class="s">&quot;</span>
+    )
 
+    <span class="k">if</span> jnt[<span class="s">&quot;min_faces&quot;</span>] &lt; STONE_SHELL_FACES_MIN:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">stone shell faces </span>{jnt[<span class="s">&#x27;min_faces&#x27;</span>]}<span class="s"> &lt; </span>{STONE_SHELL_FACES_MIN}<span class="s">&quot;</span>,
+            <span class="n">19</span>,
+        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
     <span class="k">if</span> <span class="k">not</span> (BASE_TRIS_MIN &lt;= base_tris &lt;= BASE_TRIS_MAX):
         <span class="k">return</span> fail(
             <span class="s">f&quot;</span><span class="s">base tris </span>{base_tris}<span class="s"> not in [</span>{BASE_TRIS_MIN}<span class="s">, </span>{BASE_TRIS_MAX}<span class="s">]</span><span class="s">&quot;</span>,
@@ -998,6 +1271,18 @@ <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> jnt[<span class="s">&quot;n_stones&quot;</span>] != N_ROCKS <span class="k">or</span> jnt[<span class="s">&quot;poke_z&quot;</span>] &lt; ROCK_ZMIN:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">poke stones=</span>{jnt[<span class="s">&#x27;n_stones&#x27;</span>]}<span class="s"> poke_z=</span>{jnt[<span class="s">&#x27;poke_z&#x27;</span>]:<span class="s">.5f</span>}<span class="s">&quot;</span>,
+            <span class="n">17</span>,
+        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+    <span class="k">if</span> jnt[<span class="s">&quot;float_off&quot;</span>] &gt; ROCK_SEAT_MAX:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">float_off </span>{jnt[<span class="s">&#x27;float_off&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> &gt; </span>{ROCK_SEAT_MAX}<span class="s">&quot;</span>,
+            <span class="n">18</span>,
+        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+    <span class="k">if</span> bb[<span class="n">2</span>] &gt; ZMIN_EPS:
+        <span class="k">return</span> fail(<span class="s">f&quot;</span><span class="s">grounded zmin=</span>{bb[<span class="n">2</span>]:<span class="s">.5f</span>}<span class="s">&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
@@ -1031,6 +1316,16 @@ <h2>Source</h2>
         ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
     <span class="k">if</span> export_size &lt;= <span class="n">0</span>:
         <span class="k">return</span> fail(<span class="s">&quot;export file missing or empty&quot;</span>, <span class="n">13</span>), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+    <span class="k">if</span> (
+        hyg[<span class="s">&quot;loose_v&quot;</span>] <span class="k">or</span> hyg[<span class="s">&quot;loose_e&quot;</span>] <span class="k">or</span> hyg[<span class="s">&quot;nonman&quot;</span>] <span class="k">or</span> hyg[<span class="s">&quot;zero_area&quot;</span>]
+        <span class="k">or</span> hyg[<span class="s">&quot;doubles&quot;</span>] <span class="k">or</span> hyg[<span class="s">&quot;ngons&quot;</span>] <span class="k">or</span> zf
+    ):
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">hygiene loose_v=</span>{hyg[<span class="s">&#x27;loose_v&#x27;</span>]}<span class="s"> loose_e=</span>{hyg[<span class="s">&#x27;loose_e&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">f&quot;</span><span class="s">nonman=</span>{hyg[<span class="s">&#x27;nonman&#x27;</span>]}<span class="s"> zero_area=</span>{hyg[<span class="s">&#x27;zero_area&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">f&quot;</span><span class="s">doubles=</span>{hyg[<span class="s">&#x27;doubles&#x27;</span>]}<span class="s"> ngons=</span>{hyg[<span class="s">&#x27;ngons&#x27;</span>]}<span class="s"> zfight=</span>{zf}<span class="s">&quot;</span>,
+            <span class="n">15</span>,
+        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
     <span class="k">return</span> <span class="n">0</span>, low, high, dirt, tex, collider
 
 
@@ -1144,14 +1439,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;--poke-rock&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--float-rocks&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--box-rocks&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
     args = p.parse_args(argv)
 
-    code, low, _high, dirt, tex, _col = check(args.skip_decimate)
+    code, low, _high, dirt, tex, _col = check(
+        args.skip_decimate,
+        lift_z=args.lift_z,
+        stray_vert=args.stray_vert,
+        poke=args.poke_rock,
+        float_up=args.float_rocks,
+        box_rocks=args.box_rocks,
+    )
     <span class="k">if</span> code:
         <span class="k">return</span> code
     <span class="k">if</span> args.output:
diff --git a/showcase/README.md b/showcase/README.md
index 615a944..673d997 100644
--- a/showcase/README.md
+++ b/showcase/README.md
@@ -89,6 +89,13 @@ entry in `showcase/gallery.json`, and a rendered still.
   vertices as inner ones the moment the host is out of round, which is
   how a hoop that visibly gapped on one side still passed. The paired
   falsifier makes the wrapper a true circle on an out-of-round host.
+- **Sampled host seat (exit 17/18 on scatter).** Instanced scatter
+  seats by sampling the host surface Z at each instance's XY, biting a
+  named depth, then clamping instance verts above the slab floor. A
+  closed-form icosphere (or equivalent) replaces the GN cube so the
+  scatter is stones, not open crates; a per-shell face floor is the
+  budget that catches a cube leftover (exit 19). `--poke-rock` skips
+  the clamp and over-bites; `--float-rocks` seats above the host.
 - **Plumb and real-world size (exit 19).** Assert that the axis of a
   turned or lofted body is vertical, by comparing the XY centroid of a
   bottom slab against a top slab — not the exact `zmin` and `zmax`
diff --git a/showcase/gallery.json b/showcase/gallery.json
index f2fd6f0..eabb590 100644
--- a/showcase/gallery.json
+++ b/showcase/gallery.json
@@ -92,8 +92,8 @@
     {
       "name": "terrain-scatter",
       "dir": "showcase/terrain-scatter",
-      "teaches": "A Geometry Nodes hill tile with masonry scatter through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.",
-      "witnessesFix": "Recomputed: 1194 tris, two materials with 486 stone faces, UVs in 0..1 with zero AABB overlap, outer AABB 1.800×1.800×0.655 m, LOD ratios in band, convex collider 52 tris, non-empty glTF. --skip-decimate exits 9 on the LOD1 ratio budget.",
+      "teaches": "A Geometry Nodes hill tile with seated icosphere scatter through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.",
+      "witnessesFix": "Recomputed: 1758 tris, two materials with 720 stone faces, UVs in 0..1 with zero AABB overlap, outer AABB 1.800×1.800×0.552 m, grounded zmin, 9 stones of ≥80 faces seated on sampled dirt Z (offset −35 mm, floor zmin 0.113 m), LOD ratios in band, convex collider 81 tris, hygiene zero, non-empty glTF. --skip-decimate exits 9; --stray-vert 15; --lift-z 16; --poke-rock 17; --float-rocks 18; --box-rocks 19.",
       "hero": "docs/gallery/assets/terrain-scatter-hero.webp",
       "preview": "showcase/terrain-scatter/preview.webp",
       "tags": [
@@ -140,8 +140,8 @@
     {
       "name": "park-bench",
       "dir": "showcase/park-bench",
-      "teaches": "A procedural wrought-iron park bench through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.",
-      "witnessesFix": "Recomputed: 2100 tris, two materials with 510 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 1.080×0.566×0.853 m, LOD ratios in band (5.2 COLLAPSE more aggressive on LOD2), convex collider 106 tris, non-empty glTF. --skip-decimate exits 9 on the LOD1 ratio budget.",
+      "teaches": "A procedural wrought-iron park bench with tangent tube scroll feet through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.",
+      "witnessesFix": "Recomputed: 2520 tris, two materials with 540 metal and 756 wood faces, UVs in 0..1 with zero AABB overlap, outer AABB 1.295×0.632×0.884 m, grounded zmin, 4 named toes, stretcher gap 1.2 mm, slat gap 0.3 mm, seat span 1.272 m, LOD ratios in band, convex collider 82 tris, hygiene zero, non-empty glTF. --skip-decimate exits 9; --stray-vert 15; --lift-z/--short-feet 16; --float-stretcher 17; --gap-slats 18; --narrow-seat 19.",
       "hero": "docs/gallery/assets/park-bench-hero.webp",
       "preview": "showcase/park-bench/preview.webp",
       "tags": [
diff --git a/showcase/park-bench/README.md b/showcase/park-bench/README.md
index 8760682..57b7df5 100644
--- a/showcase/park-bench/README.md
+++ b/showcase/park-bench/README.md
@@ -1,9 +1,16 @@
 # Park bench
 
 A showcase piece, not an example. Procedural wrought-iron park bench
-(scrolled legs, slatted seat and back, armrests) then the shipped
-pipeline: unique-cell UVs, Cycles high-to-low normal bake, LOD chain,
-convex collider, Unity glTF export.
+(quarter-circle tube scroll feet tangent to the posts, slatted seat and
+back, arm scrolls, wood arm caps) then the shipped pipeline: unique-cell
+UVs, Cycles high-to-low normal bake, LOD chain, convex collider, Unity
+glTF export.
+
+Posts, feet, stretchers and arms share named stations (`hx`, `hy`,
+`SEAT_Z`, `ARM_Z`, `SCROLL_R`). A foot is a 6-gon tube about
+`(hy ± R, R)` so it is tangent to the post at `z=R` and plants at `z=0`.
+The H-stretcher meets the posts at those stations; slats insert into the
+post volume without sharing corner verts with the seat rails.
 
 It asserts **budget conformance** of the generated result. It does not
 witness an API contract. "It rendered without error" is not a check.
@@ -13,6 +20,11 @@ witness an API contract. "It rendered without error" is not a check.
 `bake_normal_high_to_low.py`, `setup_bake_target_image.py`,
 `lod_chain.py` / `decimate_to_budget.py`, `convex_hull_collider.py`,
 `export_preset_unity.py` (helpers copied, not imported as a package).
+Hygiene combinatorics match `examples/mesh-hygiene-audit` (copied, not
+imported).
+
+Intended size: 1.40 m sitting width, 0.50 m seat depth, 0.43 m seat
+height, 0.64 m arm height; outer AABB 1.295 × 0.632 × 0.884 m.
 
 ## Budgets
 
@@ -21,39 +33,89 @@ materials, UVs, evaluated LOD, collider, or export file.
 
 | Axis | Declared | Measured (4.5.11 / 5.1.2 / 5.2.1) |
 | --- | --- | --- |
-| Base triangles | 2000–2200 | 2100 / 2100 / 2100 |
-| LOD1 ratio | 0.32–0.62 of base | 0.5000 / 0.5000 / 0.4952 |
-| LOD2 ratio | 0.10–0.35 of base | 0.2200 / 0.2200 / 0.1400 |
-| Materials | exactly 2 distinct, ≥48 metal faces | 2 slots, 510 metal |
+| Base triangles | 2200–4200 | 2520 / 2520 / 2520 |
+| 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, ≥48 metal, ≥24 wood | 2 slots, 540 metal / 756 wood |
 | UVs | in `0..1`, AABB overlap ≤ 1e-5 | in range, overlap 0 |
-| Outer AABB | (1.080, 0.566, 0.853) m ± 0.01 | (1.0800, 0.5657, 0.8531), zmin 0 |
-| Collider tris | ≤ 140 | 106 |
-| Export | written, size > 0 | 159868 / 159868 / 159852 bytes |
+| Outer AABB | (1.295, 0.632, 0.884) m ± 0.015 | (1.2945, 0.6314, 0.8840), zmin 0 |
+| Collider tris | ≤ 180 | 82 |
+| Export | written, size > 0 | 188164 / 188164 / 188148 bytes |
+
+Base triangles rose from **2100 to 2520** in the quality pass: box-segment
+scrolls became 6-gon tubes. Outer AABB widened from 1.080 × 0.566 × 0.853 m
+to a 1.40 m sitting-width bench.
+
+DECIMATE COLLAPSE triangle counts are **not** guaranteed identical across
+series — the gate is a ratio band, not an exact count. This mesh matched
+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. 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 toes | 4, each `zmin` ≤ 0.002 | 4, 0.00000 |
+
+### Joint fit and seat
+
+| Axis | Declared | Measured (all three) |
+| --- | --- | --- |
+| Stretcher-to-post BVH gap | ≤ 0.008 m | 0.00120 |
+| Slat-to-post BVH gap | ≤ 0.008 m | 0.00028 |
+| Seat span vs `2·hx` | ± 0.08 m | 1.2720 vs 1.260 |
 
-DECIMATE COLLAPSE triangle counts are **not** identical across series —
-5.2.1 is more aggressive on LOD2. The gate is a ratio band, not an
-exact count. Bake pixels are stochastic; the gate is `has_data` plus
-operator `FINISHED`, not byte-identity. Construction uses no RNG.
-Export byte counts differ by 16 B on 5.2.1 (glTF serializer), not a
-gated axis.
+### Falsifiers
+
+Each violates one named budget. All were run on 4.5.11, 5.1.2 and 5.2.1
+and returned the same code on each.
+
+| Flag | Budget violated | Exit |
+| --- | --- | --- |
+| `--skip-decimate` | LOD1 ratio band | 9 |
+| `--stray-vert` | loose vertex count is 0 | 15 |
+| `--lift-z` | bounding box `zmin` is 0 | 16 |
+| `--short-feet` | named toes plant at z=0 | 16 |
+| `--float-stretcher` | stretcher-to-post BVH gap | 17 |
+| `--gap-slats` | slat-to-post BVH gap | 18 |
+| `--narrow-seat` | seat span vs `2·hx` | 19 |
 
-`--skip-decimate` skips the LOD DECIMATE stage so LOD1 ratio is 1.0 and
-exit 9 fires. That is the named budget the falsifier violates.
+`--short-feet` lifts only the outward toe verts. After recenter the post
+join is the AABB `zmin`, so the AABB gate would still pass; the named-toe
+stations fail.
 
 ## Run
 
 ```bash
 blender --background --python park_bench.py --
 blender --background --python park_bench.py -- --skip-decimate
+blender --background --python park_bench.py -- --stray-vert
+blender --background --python park_bench.py -- --lift-z
+blender --background --python park_bench.py -- --short-feet
+blender --background --python park_bench.py -- --float-stretcher
+blender --background --python park_bench.py -- --gap-slats
+blender --background --python park_bench.py -- --narrow-seat
 blender --background --python park_bench.py -- --output bench.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 |
 | --- | --- |
@@ -72,3 +134,8 @@ File-local. `9` is a valid check code. `10` is reserved for
 | 12 | Bake did not finish or image has no data |
 | 13 | Export file missing or empty |
 | 14 | `--output` produced no file |
+| 15 | Hygiene (`--stray-vert` lands here) |
+| 16 | Grounded zmin / named toes (`--lift-z`, `--short-feet`) |
+| 17 | Stretcher-to-post gap (`--float-stretcher`) |
+| 18 | Slat-to-post gap (`--gap-slats`) |
+| 19 | Seat span (`--narrow-seat`) |
diff --git a/showcase/park-bench/park_bench.py b/showcase/park-bench/park_bench.py
index d74d12b..4fd1cea 100644
--- a/showcase/park-bench/park_bench.py
+++ b/showcase/park-bench/park_bench.py
@@ -1,17 +1,24 @@
 """Game-ready park bench — a showcase piece, not an example.
 
-Asserts budget conformance of a procedural wrought-iron bench (scrolled
-legs, slatted seat and back) 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 wrought-iron bench (quarter-
+circle scroll feet tangent to the posts, slatted seat and back, arm
+scrolls) after composing shipped pipeline pieces: bmesh construction,
+UVs, two materials, high-to-low normal bake, LOD chain, convex collider,
+Unity glTF export.
+
+Posts, feet, stretchers and arms share named stations (hx, hy, SEAT_Z,
+ARM_Z, SCROLL_R). A foot is a quarter-circle about (hy ± R, R) so it is
+tangent to the post at z=R and plants at z=0.
 
 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`` LOD, ``--stray-vert`` hygiene, ``--lift-z``
+zmin, ``--short-feet`` named toes, ``--float-stretcher`` stretcher seat,
+``--gap-slats`` slat-to-rail, ``--narrow-seat`` sitting width.
 
-No RNG. Construction is closed-form. DECIMATE COLLAPSE triangle counts
-are not byte-identical across Blender versions — the LOD gate is a
-ratio band, not an exact count.
+No RNG. Slat widths use closed-form ``sin(i)``. DECIMATE COLLAPSE
+triangle counts are not byte-identical across Blender versions — the LOD
+gate is a ratio band, not an exact count.
 
     blender --background --python park_bench.py --
     blender --background --python park_bench.py -- --skip-decimate
@@ -27,6 +34,7 @@
 import bmesh
 import bpy
 from mathutils import Euler, Vector
+from mathutils.bvhtree import BVHTree
 
 _REPO = os.path.abspath(
     os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir, os.pardir)
@@ -35,22 +43,30 @@
 sys.dont_write_bytecode = True
 import gallery_framing  # noqa: E402
 
-SEAT_W = 1.18
-SEAT_D = 0.46
-SEAT_Z = 0.44
-N_SEAT = 6
-N_BACK = 4
-SLAT_T = 0.032
-BACK_H = 0.40
-IRON_T = 0.026
-SCROLL_R = 0.10
+SEAT_W = 1.40
+SEAT_D = 0.50
+SEAT_Z = 0.43
+N_SEAT = 7
+N_BACK = 5
+SLAT_T = 0.030
+BACK_H = 0.38
+IRON_T = 0.024
+SCROLL_R = 0.11
 SCROLL_N = 12
-ARM_Z = 0.62
-
-BBOX_TOL = 0.01
-OUTER_SIZE = (1.080, 0.566, 0.853)
-BASE_TRIS_MIN = 2000
-BASE_TRIS_MAX = 2200
+ARM_Z = 0.64
+ARM_SCROLL_R = 0.055
+STRETCHER_Z = 0.16
+POST_INSET_X = 0.07
+POST_INSET_Y = 0.045
+HX = SEAT_W / 2.0 - POST_INSET_X
+HY = SEAT_D / 2.0 - POST_INSET_Y
+SEAT_SPAN = 2.0 * HX
+SEAT_SPAN_TOL = 0.08
+
+BBOX_TOL = 0.015
+OUTER_SIZE = (1.295, 0.632, 0.884)
+BASE_TRIS_MIN = 2200
+BASE_TRIS_MAX = 4200
 LOD1_RATIO_MIN = 0.32
 LOD1_RATIO_MAX = 0.62
 LOD2_RATIO_MIN = 0.10
@@ -60,11 +76,25 @@
 MATERIAL_COUNT = 2
 UV_EPS = 1e-4
 UV_OVERLAP_MAX = 1e-5
-COLLIDER_TRIS_MAX = 140
+COLLIDER_TRIS_MAX = 180
 BAKE_RES = 256
 CAGE_EXTRUSION = 0.08
 METAL_FACES_MIN = 48
 WOOD_FACES_MIN = 24
+ZMIN_EPS = 1e-4
+DOUBLES_EPS = 1e-5
+AREA_EPS = 1e-10
+ZFIGHT_EPS = 1e-4
+ZFIGHT_COS = 0.998
+STRETCHER_GAP_MAX = 0.008
+SLAT_GAP_MAX = 0.008
+TOE_COUNT = 4
+TOE_ZMIN_MAX = 0.002
+FLOAT_STRETCHER = 0.10
+GAP_SLAT = 0.10
+SHORT_FOOT = 0.16
+LIFT_Z = 0.05
+NARROW_SEAT = 0.55
 
 WOOD_IDX = 0
 METAL_IDX = 1
@@ -134,16 +164,70 @@ def add_oriented_box(bm, a, b, scale_xy, mat_idx):
     )
 
 
-def add_arc_yz(bm, x, cy, cz, radius, a0, a1, n, thick, mat_idx):
+def add_arc_yz(bm, x, cy, cz, radius, a0, a1, n, thick, mat_idx, t0=0.0, t1=1.0):
     pts = []
     for i in range(n + 1):
-        t = i / n
+        t = t0 + (t1 - t0) * (i / n)
         ang = a0 + (a1 - a0) * t
-        pts.append((x, cy + radius * math.cos(ang), cz + radius * math.sin(ang)))
-    verts = []
-    for p0, p1 in zip(pts, pts[1:]):
-        verts.extend(add_oriented_box(bm, p0, p1, (thick, thick), mat_idx))
-    return verts
+        pts.append(Vector((x, cy + radius * math.cos(ang), cz + radius * math.sin(ang))))
+    rings = 6
+    r = thick * 0.5
+    ring_verts = []
+    for i, p in enumerate(pts):
+        if i < n:
+            tangent = (pts[i + 1] - p).normalized()
+        else:
+            tangent = (p - pts[i - 1]).normalized()
+        side = tangent.cross(Vector((1.0, 0.0, 0.0)))
+        if side.length < 1e-6:
+            side = tangent.cross(Vector((0.0, 1.0, 0.0)))
+        side.normalize()
+        up = tangent.cross(side).normalized()
+        ring = []
+        for k in range(rings):
+            ang = (2.0 * math.pi * k) / rings
+            offset = side * math.cos(ang) * r + up * math.sin(ang) * r
+            ring.append(bm.verts.new(p + offset))
+        ring_verts.append(ring)
+    bm.verts.ensure_lookup_table()
+    bm.faces.ensure_lookup_table()
+    for a, b in zip(ring_verts, ring_verts[1:]):
+        for k in range(rings):
+            k2 = (k + 1) % rings
+            face = bm.faces.new((a[k], a[k2], b[k2], b[k]))
+            face.material_index = mat_idx
+    for end_i, p in ((0, pts[0]), (-1, pts[-1])):
+        center = bm.verts.new(p)
+        ring = ring_verts[end_i]
+        for k in range(rings):
+            k2 = (k + 1) % rings
+            if end_i == 0:
+                face = bm.faces.new((center, ring[k2], ring[k]))
+            else:
+                face = bm.faces.new((center, ring[k], ring[k2]))
+            face.material_index = mat_idx
+    return [v for ring in ring_verts for v in ring]
+
+
+def add_foot_scroll(bm, x, y_post, y_out, thick, mat_idx):
+    """Quarter-circle from post join (y_post, R) to toe (y_out, 0)."""
+    cy = y_out
+    cz = SCROLL_R
+    if y_out < y_post:
+        a0, a1 = 0.0, -math.pi / 2.0
+    else:
+        a0, a1 = math.pi, 1.5 * math.pi
+    return add_arc_yz(
+        bm, x, cy, cz, SCROLL_R, a0, a1, SCROLL_N, thick, mat_idx, t0=0.08, t1=1.0
+    )
+
+
+def add_arm_scroll(bm, x, y_post, thick, mat_idx):
+    cy = y_post - ARM_SCROLL_R
+    cz = ARM_Z
+    return add_arc_yz(
+        bm, x, cy, cz, ARM_SCROLL_R, 0.0, -math.pi / 2.0, 8, thick, mat_idx, t0=0.08, t1=1.0
+    )
 
 
 def pack_uvs(bm, margin=0.08):
@@ -189,34 +273,70 @@ def pack_uvs(bm, margin=0.08):
             )
 
 
-def build_bench_mesh(name, bevel_offset, bevel_segments):
+def build_bench_mesh(
+    name,
+    bevel_offset,
+    bevel_segments,
+    float_stretcher=False,
+    gap_slats=False,
+    short_feet=False,
+    narrow_seat=False,
+):
     bm = bmesh.new()
     try:
         wood = []
-        hx = SEAT_W / 2.0 - 0.08
-        hy = SEAT_D / 2.0 - 0.05
-        # Span past the post centers (±hx) so slats insert into the iron frame.
-        slat_span = 2.0 * hx + IRON_T
-        usable = SEAT_D - 0.08
-        slat_w = usable / N_SEAT
-        y0 = -hy + slat_w / 2.0 + 0.01
+        t = IRON_T
+        hx, hy = HX, HY
+        slat_span = SEAT_SPAN + t * 0.50
+        if gap_slats:
+            slat_span = SEAT_SPAN - IRON_T - 0.024
+        if narrow_seat:
+            slat_span = SEAT_SPAN * NARROW_SEAT
+
+        usable = 2.0 * hy - 0.06
+        gap = 0.010
+        widths = []
         for i in range(N_SEAT):
-            y = y0 + i * slat_w
+            widths.append(1.0 + 0.10 * math.sin(i * 1.7 + 0.3))
+        scale = (usable - gap * (N_SEAT - 1)) / sum(widths)
+        y_cursor = -hy + 0.03
+        for i, w in enumerate(widths):
+            slat_w = w * scale
+            y = y_cursor + slat_w * 0.5
             wood.extend(
                 add_box(
                     bm,
                     (0.0, y, SEAT_Z + SLAT_T / 2.0),
-                    (slat_span, slat_w * 0.78, SLAT_T),
+                    (slat_span, slat_w * 0.92, SLAT_T),
                     WOOD_IDX,
                 )
             )
-        for i in range(N_BACK):
-            z = SEAT_Z + SLAT_T + 0.05 + i * (BACK_H / N_BACK)
+            y_cursor += slat_w + gap
+
+        back_span = BACK_H - 0.04
+        bwidths = [1.0 + 0.08 * math.sin(i * 1.4 + 0.8) for i in range(N_BACK)]
+        bscale = (back_span - gap * (N_BACK - 1)) / sum(bwidths)
+        z_cursor = SEAT_Z + SLAT_T + 0.04
+        for w in bwidths:
+            slat_h = w * bscale
+            z = z_cursor + slat_h * 0.5
             wood.extend(
                 add_box(
                     bm,
                     (0.0, hy, z),
-                    (slat_span, SLAT_T, slat_w * 0.72),
+                    (slat_span, SLAT_T, slat_h * 0.90),
+                    WOOD_IDX,
+                )
+            )
+            z_cursor += slat_h + gap
+
+        for xsign in (-1.0, 1.0):
+            x = xsign * hx
+            wood.extend(
+                add_box(
+                    bm,
+                    (x, 0.0, ARM_Z + t * 0.5 + SLAT_T * 0.5),
+                    (SLAT_T * 1.15, 2.0 * hy + t, SLAT_T),
                     WOOD_IDX,
                 )
             )
@@ -235,14 +355,13 @@ def build_bench_mesh(name, bevel_offset, bevel_segments):
             for f in ret.get("faces") or []:
                 f.material_index = WOOD_IDX
 
-        t = IRON_T
-        add_box(bm, (0.0, -hy, SEAT_Z - 0.018), (SEAT_W - 0.10, t * 1.15, t), METAL_IDX)
-        add_box(bm, (0.0, hy, SEAT_Z - 0.018), (SEAT_W - 0.10, t * 1.15, t), METAL_IDX)
+        add_box(bm, (0.0, -hy, SEAT_Z - t * 0.35), (SEAT_SPAN, t, t), METAL_IDX)
+        add_box(bm, (0.0, hy, SEAT_Z - t * 0.35), (SEAT_SPAN, t, t), METAL_IDX)
         for xsign in (-1.0, 1.0):
             add_box(
                 bm,
-                (xsign * hx, 0.0, SEAT_Z - 0.018),
-                (t * 1.15, SEAT_D - 0.08, t),
+                (xsign * hx, 0.0, SEAT_Z - t * 0.35),
+                (t, 2.0 * hy, t),
                 METAL_IDX,
             )
 
@@ -250,68 +369,49 @@ def build_bench_mesh(name, bevel_offset, bevel_segments):
         for xsign in (-1.0, 1.0):
             x = xsign * hx
             add_oriented_box(
-                bm, (x, hy, SEAT_Z), (x, hy, back_top), (t, t), METAL_IDX
+                bm, (x, hy, SCROLL_R), (x, hy, back_top), (t, t), METAL_IDX
             )
             add_oriented_box(
-                bm, (x, -hy, SEAT_Z), (x, -hy, ARM_Z), (t, t), METAL_IDX
+                bm, (x, -hy, SCROLL_R), (x, -hy, ARM_Z), (t, t), METAL_IDX
             )
             add_oriented_box(
-                bm, (x, -hy, ARM_Z), (x, hy, ARM_Z), (t * 0.9, t * 0.9), METAL_IDX
+                bm, (x, -hy, ARM_Z), (x, hy, ARM_Z), (t * 0.95, t * 0.95), METAL_IDX
             )
-            add_oriented_box(
-                bm,
-                (x, -hy, SCROLL_R + 0.02),
-                (x, -hy, SEAT_Z),
-                (t, t),
-                METAL_IDX,
-            )
-            add_oriented_box(
-                bm,
-                (x, hy, SCROLL_R + 0.02),
-                (x, hy, SEAT_Z),
-                (t, t),
-                METAL_IDX,
-            )
-            add_arc_yz(
-                bm,
-                x,
-                -hy + 0.01,
-                SCROLL_R,
-                SCROLL_R,
-                math.pi / 2.0,
-                math.pi + 0.45,
-                SCROLL_N,
-                t,
-                METAL_IDX,
-            )
-            add_arc_yz(
-                bm,
-                x,
-                hy - 0.01,
-                SCROLL_R,
-                SCROLL_R,
-                math.pi / 2.0,
-                -0.45,
-                SCROLL_N,
-                t,
-                METAL_IDX,
-            )
-            add_arc_yz(
-                bm,
-                x,
-                -hy - 0.02,
-                ARM_Z - 0.04,
-                0.07,
-                math.pi * 0.15,
-                math.pi * 0.95,
-                10,
-                t * 0.85,
-                METAL_IDX,
-            )
-
-        add_box(bm, (0.0, hy, back_top), (SEAT_W - 0.12, t, t), METAL_IDX)
-        add_box(bm, (0.0, 0.0, 0.18), (SEAT_W - 0.22, t * 0.9, t * 0.9), METAL_IDX)
-        add_box(bm, (0.0, 0.0, 0.18), (t * 0.9, SEAT_D - 0.14, t * 0.9), METAL_IDX)
+            add_foot_scroll(bm, x, -hy, -hy - SCROLL_R, t, METAL_IDX)
+            add_foot_scroll(bm, x, hy, hy + SCROLL_R, t, METAL_IDX)
+            add_arm_scroll(bm, x, -hy, t * 0.90, METAL_IDX)
+
+        add_box(bm, (0.0, hy, back_top), (SEAT_SPAN, t, t), METAL_IDX)
+
+        st_trim = FLOAT_STRETCHER if float_stretcher else 0.0
+        yx = hx - st_trim
+        add_oriented_box(
+            bm,
+            (-yx, -hy, STRETCHER_Z),
+            (-yx, hy, STRETCHER_Z),
+            (t * 0.9, t * 0.9),
+            METAL_IDX,
+        )
+        add_oriented_box(
+            bm,
+            (yx, -hy, STRETCHER_Z),
+            (yx, hy, STRETCHER_Z),
+            (t * 0.9, t * 0.9),
+            METAL_IDX,
+        )
+        cx_end = yx - t * 0.40
+        add_oriented_box(
+            bm,
+            (-cx_end, 0.0, STRETCHER_Z),
+            (cx_end, 0.0, STRETCHER_Z),
+            (t * 0.9, t * 0.9),
+            METAL_IDX,
+        )
+
+        if short_feet:
+            for v in bm.verts:
+                if v.co.z < SCROLL_R * 0.55 and abs(v.co.y) > hy + SCROLL_R * 0.35:
+                    v.co.z += SHORT_FOOT
 
         xs = [v.co.x for v in bm.verts]
         ys = [v.co.y for v in bm.verts]
@@ -326,15 +426,18 @@ def build_bench_mesh(name, bevel_offset, bevel_segments):
             if v.co.z < 0.0:
                 v.co.z = 0.0
 
+        ngons = [f for f in bm.faces if len(f.verts) > 4]
+        if ngons:
+            bmesh.ops.triangulate(bm, faces=ngons)
         pack_uvs(bm)
         bmesh.ops.recalc_face_normals(bm, faces=list(bm.faces))
         for face in bm.faces:
-            face.smooth = False
+            face.smooth = face.material_index == METAL_IDX
         me = bpy.data.meshes.new(name)
         bm.to_mesh(me)
         me.update()
         for poly in me.polygons:
-            poly.use_smooth = False
+            poly.use_smooth = poly.material_index == METAL_IDX
     finally:
         bm.free()
     out = bpy.data.objects.new(name, me)
@@ -342,13 +445,25 @@ def build_bench_mesh(name, bevel_offset, bevel_segments):
     return out
 
 
-def principled(name, color, metallic, roughness):
+def principled(name, color, metallic, roughness, noise_scale=0.0, wear=None):
     mat = bpy.data.materials.new(name)
     mat.use_nodes = True
-    bsdf = mat.node_tree.nodes["Principled BSDF"]
+    nt = mat.node_tree
+    bsdf = nt.nodes["Principled BSDF"]
     bsdf.inputs["Base Color"].default_value = color
     bsdf.inputs["Metallic"].default_value = metallic
     bsdf.inputs["Roughness"].default_value = roughness
+    if noise_scale > 0.0 and wear is not None:
+        tex = nt.nodes.new("ShaderNodeTexNoise")
+        tex.inputs["Scale"].default_value = noise_scale
+        tex.inputs["Detail"].default_value = 6.0
+        mix = nt.nodes.new("ShaderNodeMix")
+        mix.data_type = "RGBA"
+        mix.inputs["A"].default_value = color
+        mix.inputs["B"].default_value = wear
+        fac = mix.inputs.get("Factor") or mix.inputs.get("Fac")
+        nt.links.new(tex.outputs["Fac"], fac)
+        nt.links.new(mix.outputs["Result"], bsdf.inputs["Base Color"])
     return mat
 
 
@@ -363,10 +478,11 @@ def assign_slots(obj, wood, metal):
 
 
 def world_bbox(obj):
-    corners = [obj.matrix_world @ Vector(c) for c in obj.bound_box]
-    xs = [c.x for c in corners]
-    ys = [c.y for c in corners]
-    zs = [c.z for c in corners]
+    mat = obj.matrix_world
+    pts = [mat @ v.co for v in obj.data.vertices]
+    xs = [p.x for p in pts]
+    ys = [p.y for p in pts]
+    zs = [p.z for p in pts]
     return (min(xs), min(ys), min(zs), max(xs), max(ys), max(zs))
 
 
@@ -429,6 +545,203 @@ def convex_hull_collider(obj, name):
     return collider
 
 
+def face_area(me, poly):
+    vs = [me.vertices[i].co for i in poly.vertices]
+    if len(vs) < 3:
+        return 0.0
+    v0 = vs[0]
+    area = 0.0
+    for i in range(1, len(vs) - 1):
+        area += (vs[i] - v0).cross(vs[i + 1] - v0).length * 0.5
+    return area
+
+
+def hygiene_audit(me):
+    nv, ne, nf = len(me.vertices), len(me.edges), len(me.polygons)
+    ngons = sum(1 for p in me.polygons if len(p.vertices) > 4)
+    zero_area = sum(1 for p in me.polygons if face_area(me, p) <= AREA_EPS)
+    bm = bmesh.new()
+    try:
+        bm.from_mesh(me)
+        loose_v = sum(1 for v in bm.verts if len(v.link_edges) == 0)
+        loose_e = sum(1 for e in bm.edges if len(e.link_faces) == 0)
+        nonman = sum(1 for e in bm.edges if not e.is_manifold)
+        ret = bmesh.ops.find_doubles(bm, verts=list(bm.verts), dist=DOUBLES_EPS)
+        doubles = len(ret.get("targetmap") or {})
+    finally:
+        bm.free()
+    return {
+        "nv": nv, "ne": ne, "nf": nf, "ngons": ngons,
+        "loose_v": loose_v, "loose_e": loose_e, "nonman": nonman,
+        "zero_area": zero_area, "doubles": doubles, "euler": nv - ne + nf,
+    }
+
+
+def zfight_pairs(me):
+    data = [
+        (p.center.copy(), p.normal.copy(), frozenset(p.vertices))
+        for p in me.polygons
+    ]
+    eps2 = ZFIGHT_EPS * ZFIGHT_EPS
+    count = 0
+    for i in range(len(data)):
+        ci, ni, vi = data[i]
+        for j in range(i + 1, len(data)):
+            cj, nj, vj = data[j]
+            if (cj - ci).length_squared > eps2:
+                continue
+            if abs(ni.dot(nj)) <= ZFIGHT_COS:
+                continue
+            if vi & vj:
+                continue
+            count += 1
+    return count
+
+
+def shells(me):
+    neighbors = [[] for _ in range(len(me.vertices))]
+    for edge in me.edges:
+        a, b = edge.vertices
+        neighbors[a].append(b)
+        neighbors[b].append(a)
+    seen = [False] * len(me.vertices)
+    groups = []
+    for start in range(len(me.vertices)):
+        if seen[start]:
+            continue
+        seen[start] = True
+        stack = [start]
+        group = []
+        while stack:
+            current = stack.pop()
+            group.append(current)
+            for nxt in neighbors[current]:
+                if not seen[nxt]:
+                    seen[nxt] = True
+                    stack.append(nxt)
+        groups.append(group)
+    return groups
+
+
+def shell_aabb(me, group):
+    pts = [me.vertices[i].co for i in group]
+    return (
+        min(p.x for p in pts), min(p.y for p in pts), min(p.z for p in pts),
+        max(p.x for p in pts), max(p.y for p in pts), max(p.z for p in pts),
+    )
+
+
+def mat_of(me, group):
+    member = set(group)
+    for poly in me.polygons:
+        if all(i in member for i in poly.vertices):
+            return poly.material_index
+    return None
+
+
+def shell_bvh_gap(me, ga, gb):
+    bm_a = bmesh.new()
+    bm_b = bmesh.new()
+    try:
+        bm_a.from_mesh(me)
+        bm_b.from_mesh(me)
+        keep_a, keep_b = set(ga), set(gb)
+        drop_a = [f for f in bm_a.faces if not all(v.index in keep_a for v in f.verts)]
+        drop_b = [f for f in bm_b.faces if not all(v.index in keep_b for v in f.verts)]
+        if drop_a:
+            bmesh.ops.delete(bm_a, geom=drop_a, context="FACES")
+        if drop_b:
+            bmesh.ops.delete(bm_b, geom=drop_b, context="FACES")
+        if not bm_a.faces or not bm_b.faces:
+            return 1e9
+        tree = BVHTree.FromBMesh(bm_b)
+        best = 1e9
+        for v in bm_a.verts:
+            hit = tree.find_nearest(v.co)
+            if hit[0] is not None:
+                best = min(best, hit[3])
+        for f in bm_a.faces:
+            hit = tree.find_nearest(f.calc_center_median())
+            if hit[0] is not None:
+                best = min(best, hit[3])
+        return best
+    finally:
+        bm_a.free()
+        bm_b.free()
+
+
+def add_stray_vert(me):
+    bm = bmesh.new()
+    try:
+        bm.from_mesh(me)
+        bm.verts.new((0.0, 0.0, SEAT_Z + 0.12))
+        bm.to_mesh(me)
+        me.update()
+    finally:
+        bm.free()
+
+
+def joint_audit(me):
+    groups = shells(me)
+    posts = []
+    stretchers = []
+    slats = []
+    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 dz > 0.28 and dx < 0.08 and dy < 0.08:
+            posts.append((g, a))
+        if mat == METAL_IDX and abs(0.5 * (a[2] + a[5]) - STRETCHER_Z) < 0.05 and max(dx, dy) > 0.25:
+            stretchers.append((g, a))
+        if mat == WOOD_IDX and dz < 0.08 and dx > SEAT_SPAN * 0.4:
+            slats.append((g, a))
+    metal_verts = []
+    for poly in me.polygons:
+        if poly.material_index != METAL_IDX:
+            continue
+        for i in poly.vertices:
+            metal_verts.append(me.vertices[i].co)
+    stations = (
+        (HX, HY + SCROLL_R, 0.0),
+        (HX, -HY - SCROLL_R, 0.0),
+        (-HX, HY + SCROLL_R, 0.0),
+        (-HX, -HY - SCROLL_R, 0.0),
+    )
+    toes = 0
+    toe_z = 99.0
+    for sx, sy, sz in stations:
+        nearby = []
+        for co in metal_verts:
+            d = ((co.x - sx) ** 2 + (co.y - sy) ** 2) ** 0.5
+            if d < SCROLL_R * 0.55:
+                nearby.append(co)
+        if nearby:
+            toes += 1
+            toe_z = min(toe_z, min(c.z for c in nearby))
+    st_gap = 99.0
+    if stretchers and posts:
+        st_gap = min(shell_bvh_gap(me, s[0], p[0]) for s in stretchers for p in posts)
+    slat_gap = 99.0
+    rails = [p for p in posts]
+    if slats and rails:
+        slat_gap = min(shell_bvh_gap(me, s[0], p[0]) for s in slats for p in rails)
+    seat_x = 0.0
+    if slats:
+        xs = [v for _g, a in slats for v in (a[0], a[3])]
+        seat_x = max(xs) - min(xs)
+    return {
+        "toes": toes,
+        "toe_z": toe_z,
+        "posts": len(posts),
+        "stretchers": len(stretchers),
+        "st_gap": st_gap,
+        "slat_gap": slat_gap,
+        "seat_x": seat_x,
+        "slats": len(slats),
+    }
+
+
 def setup_bake_image(obj, target_mat, size=BAKE_RES):
     if not obj.data.uv_layers:
         return None, None
@@ -481,15 +794,42 @@ def export_unity(path, objects):
     )
 
 
-def check(skip_decimate):
+def check(
+    skip_decimate,
+    lift_z=False,
+    stray_vert=False,
+    float_stretcher=False,
+    gap_slats=False,
+    short_feet=False,
+    narrow_seat=False,
+):
     bpy.ops.wm.read_factory_settings(use_empty=True)
-    low = build_bench_mesh("BenchLow", bevel_offset=0.005, bevel_segments=2)
-    high = build_bench_mesh("BenchHigh", bevel_offset=0.005, bevel_segments=4)
-    wood = principled("BenchWood", (0.40, 0.20, 0.07, 1.0), 0.0, 0.58)
-    metal = principled("BenchIron", (0.09, 0.095, 0.11, 1.0), 1.0, 0.28)
+    kw = dict(
+        float_stretcher=float_stretcher,
+        gap_slats=gap_slats,
+        short_feet=short_feet,
+        narrow_seat=narrow_seat,
+    )
+    low = build_bench_mesh("BenchLow", bevel_offset=0.004, bevel_segments=2, **kw)
+    high = build_bench_mesh("BenchHigh", bevel_offset=0.004, bevel_segments=4, **kw)
+    wood = principled(
+        "BenchWood", (0.40, 0.20, 0.07, 1.0), 0.0, 0.58,
+        noise_scale=18.0, wear=(0.28, 0.14, 0.05, 1.0),
+    )
+    metal = principled(
+        "BenchIron", (0.09, 0.095, 0.11, 1.0), 1.0, 0.32,
+        noise_scale=22.0, wear=(0.16, 0.14, 0.10, 1.0),
+    )
     assign_slots(low, wood, metal)
     assign_slots(high, wood, metal)
 
+    if stray_vert:
+        add_stray_vert(low.data)
+    if lift_z:
+        for v in low.data.vertices:
+            v.co.z += LIFT_Z
+        low.data.update()
+
     if low.data is None or len(low.data.polygons) < 6:
         return fail("bench mesh did not build", 3), None, None, None, None, None
 
@@ -520,7 +860,9 @@ def check(skip_decimate):
     r1 = lod1_tris / base_tris if base_tris else 0.0
     r2 = lod2_tris / base_tris if base_tris else 0.0
 
-    collider_src = build_bench_mesh("BenchColSrc", bevel_offset=0.0, bevel_segments=1)
+    collider_src = build_bench_mesh(
+        "BenchColSrc", bevel_offset=0.0, bevel_segments=1, **kw
+    )
     collider = convex_hull_collider(collider_src, "BenchCollider")
     bpy.data.objects.remove(collider_src, do_unlink=True)
     col_tris = triangle_count(collider.data)
@@ -551,6 +893,20 @@ def check(skip_decimate):
         f"measured collider_tris={col_tris} bake={bake_result} "
         f"bake_has_data={img.has_data} export_bytes={export_size}"
     )
+    hyg = hygiene_audit(low.data)
+    zf = zfight_pairs(low.data)
+    jnt = joint_audit(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 toes={jnt['toes']} toe_z={jnt['toe_z']:.5f} "
+        f"posts={jnt['posts']} stretchers={jnt['stretchers']} "
+        f"st_gap={jnt['st_gap']:.5f} slat_gap={jnt['slat_gap']:.5f} "
+        f"seat_x={jnt['seat_x']:.4f} slats={jnt['slats']}"
+    )
 
     if not (BASE_TRIS_MIN <= base_tris <= BASE_TRIS_MAX):
         return fail(
@@ -582,6 +938,16 @@ def check(skip_decimate):
             f"UV AABB overlap {overlap:.6f} > {UV_OVERLAP_MAX}",
             7,
         ), None, None, None, None, None
+    if abs(jnt["seat_x"] - SEAT_SPAN) > SEAT_SPAN_TOL:
+        return fail(
+            f"seat span {jnt['seat_x']:.4f} off {SEAT_SPAN}",
+            19,
+        ), None, None, None, None, None
+    if bb[2] > ZMIN_EPS or jnt["toes"] != TOE_COUNT or jnt["toe_z"] > TOE_ZMIN_MAX:
+        return fail(
+            f"grounded zmin={bb[2]:.5f} toes={jnt['toes']} toe_z={jnt['toe_z']:.5f}",
+            16,
+        ), None, None, None, None, None
     if (
         abs(size_x - OUTER_SIZE[0]) > BBOX_TOL
         or abs(size_y - OUTER_SIZE[1]) > BBOX_TOL
@@ -615,6 +981,26 @@ def check(skip_decimate):
         ), None, None, None, None, None
     if export_size <= 0:
         return fail("export file missing or empty", 13), None, None, None, None, None
+    if (
+        hyg["loose_v"] or hyg["loose_e"] or hyg["nonman"] or hyg["zero_area"]
+        or hyg["doubles"] or hyg["ngons"] or zf
+    ):
+        return fail(
+            f"hygiene loose_v={hyg['loose_v']} loose_e={hyg['loose_e']} "
+            f"nonman={hyg['nonman']} zero_area={hyg['zero_area']} "
+            f"doubles={hyg['doubles']} ngons={hyg['ngons']} zfight={zf}",
+            15,
+        ), None, None, None, None, None
+    if jnt["stretchers"] < 2 or jnt["st_gap"] > STRETCHER_GAP_MAX:
+        return fail(
+            f"stretcher gap {jnt['st_gap']:.5f} stretchers={jnt['stretchers']}",
+            17,
+        ), None, None, None, None, None
+    if jnt["slats"] < 4 or jnt["slat_gap"] > SLAT_GAP_MAX:
+        return fail(
+            f"slat gap {jnt['slat_gap']:.5f} slats={jnt['slats']}",
+            18,
+        ), None, None, None, None, None
     return 0, low, high, wood, tex, collider
 
 
@@ -682,10 +1068,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.95, -2.55, 1.22)
+    cam.location = (2.22, -2.90, 1.34)
     scene.collection.objects.link(cam)
     aim = bpy.data.objects.new("Aim", None)
-    aim.location = (0.0, 0.0, 0.40)
+    aim.location = (0.0, 0.0, 0.42)
     scene.collection.objects.link(aim)
     con = cam.constraints.new("TRACK_TO")
     con.target = aim
@@ -728,14 +1114,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-feet", action="store_true")
+    p.add_argument("--float-stretcher", action="store_true")
+    p.add_argument("--gap-slats", action="store_true")
+    p.add_argument("--narrow-seat", action="store_true")
     args = p.parse_args(argv)
 
-    code, low, _high, wood, tex, _col = check(args.skip_decimate)
+    code, low, _high, wood, tex, _col = check(
+        args.skip_decimate,
+        lift_z=args.lift_z,
+        stray_vert=args.stray_vert,
+        float_stretcher=args.float_stretcher,
+        gap_slats=args.gap_slats,
+        short_feet=args.short_feet,
+        narrow_seat=args.narrow_seat,
+    )
     if code:
         return code
     if args.output:
diff --git a/showcase/park-bench/preview.webp b/showcase/park-bench/preview.webp
index e7523f0..3305f65 100644
Binary files a/showcase/park-bench/preview.webp and b/showcase/park-bench/preview.webp differ
diff --git a/showcase/terrain-scatter/README.md b/showcase/terrain-scatter/README.md
index 499afe1..1a77db2 100644
--- a/showcase/terrain-scatter/README.md
+++ b/showcase/terrain-scatter/README.md
@@ -2,9 +2,15 @@
 
 A showcase piece, not an example. Geometry Nodes sine-hill Mesh Grid
 with an Index-jittered Instance-on-Points scatter, realized cubes
-replaced by bevelled masonry, then the shipped pipeline: unique-cell
-UVs, Cycles high-to-low normal bake, LOD chain, convex collider,
-Unity glTF export.
+replaced by closed-form displaced icospheres seated on sampled dirt Z,
+then the shipped pipeline: unique-cell UVs, Cycles high-to-low normal
+bake, LOD chain, convex collider, Unity glTF export.
+
+GN still builds the hill and the instance grid. After realize+slabify,
+cube islands are deleted and each centroid is reseated: stone `zmin`
+equals sampled dirt Z minus a named bite, then verts clamp above the
+slab floor. That is why rocks sit on the hill instead of punching
+through the slab as bevelled crates.
 
 It asserts **budget conformance** of the generated result. It does not
 witness an API contract. "It rendered without error" is not a check.
@@ -13,8 +19,12 @@ witness an API contract. "It rendered without error" is not a check.
 `bake-high-to-low`, `depsgraph-and-evaluated-data`,
 `engine-export-presets`, and snippets `bake_normal_high_to_low.py`,
 `setup_bake_target_image.py`, `lod_chain.py` / `decimate_to_budget.py`,
-`convex_hull_collider.py`, `export_preset_unity.py` (helpers copied,
-not imported as a package).
+`convex_hull_collider.py`, `export_preset_unity.py` (helpers copied, not
+imported as a package). Hygiene combinatorics match
+`examples/mesh-hygiene-audit` (copied, not imported).
+
+Intended size: 1.80 m square hill tile, ~0.16 m sine amplitude, nine
+seated stones; outer AABB 1.800 × 1.800 × 0.552 m.
 
 ## Budgets
 
@@ -23,38 +33,79 @@ materials, UVs, evaluated LOD, collider, or export file.
 
 | Axis | Declared | Measured (4.5.11 / 5.1.2 / 5.2.1) |
 | --- | --- | --- |
-| Base triangles | 1150–1250 | 1194 / 1194 / 1194 |
-| LOD1 ratio | 0.32–0.62 of base | 0.4992 / 0.4992 / 0.4992 |
-| LOD2 ratio | 0.10–0.35 of base | 0.2194 / 0.2194 / 0.2194 |
-| Materials | exactly 2 distinct, ≥24 stone faces | 2 slots, 486 stone |
+| Base triangles | 1400–2800 | 1758 / 1758 / 1758 |
+| LOD1 ratio | 0.32–0.62 of base | 0.4994 / 0.4994 / 0.4994 |
+| LOD2 ratio | 0.10–0.35 of base | 0.2196 / 0.2196 / 0.2196 |
+| Materials | exactly 2 distinct, ≥24 stone faces | 2 slots, 720 stone |
 | UVs | in `0..1`, AABB overlap ≤ 1e-5 | in range, overlap 0 |
-| Outer AABB | (1.800, 1.800, 0.655) m ± 0.01 | (1.8000, 1.8000, 0.6554), zmin 0 |
-| Collider tris | ≤ 80 | 52 |
-| Export | written, size > 0 | 90704 / 90704 / 90696 bytes |
+| Outer AABB | (1.800, 1.800, 0.552) m ± 0.015 | (1.8000, 1.8000, 0.5523), zmin 0 |
+| Collider tris | ≤ 120 | 81 |
+| Export | written, size > 0 | 158156 / 158156 / 158140 bytes |
+
+Base triangles rose from **1194 to 1758** in the quality pass: 9-vert hill
+became a 21-vert grid, and bevelled cubes became subdiv-2 icospheres.
+Outer Z dropped from 0.655 m (crate corners swinging through the slab)
+to 0.552 m of seated stone on the hill.
 
 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 may differ by a few bytes across series.
+series — the gate is a ratio band, not an exact count. This mesh matched
+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. 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.
 
-`--skip-decimate` skips the LOD DECIMATE stage so LOD1 ratio is 1.0 and
-exit 9 fires. That is the named budget the falsifier violates.
+| Axis | Declared | Measured (all three) |
+| --- | --- | --- |
+| 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 |
+| Stone shells | 9 | 9 |
+| Per-stone faces | ≥ 40 | 80 |
+| Stone floor `zmin` | ≥ 0.012 m | 0.11334 |
+| Seat offset (`zmin` − dirt Z) | ≤ 0.02 m | −0.03500 |
+
+### Falsifiers
+
+Each violates one named budget. All were run on 4.5.11, 5.1.2 and 5.2.1
+and returned the same code on each.
+
+| Flag | Budget violated | Exit |
+| --- | --- | --- |
+| `--skip-decimate` | LOD1 ratio band | 9 |
+| `--stray-vert` | loose vertex count is 0 | 15 |
+| `--lift-z` | bounding box `zmin` is 0 | 16 |
+| `--poke-rock` | stone floor `zmin` | 17 |
+| `--float-rocks` | seat offset vs sampled dirt Z | 18 |
+| `--box-rocks` | per-stone face floor | 19 |
 
 ## Run
 
 ```bash
 blender --background --python terrain_scatter.py --
 blender --background --python terrain_scatter.py -- --skip-decimate
+blender --background --python terrain_scatter.py -- --stray-vert
+blender --background --python terrain_scatter.py -- --lift-z
+blender --background --python terrain_scatter.py -- --poke-rock
+blender --background --python terrain_scatter.py -- --float-rocks
+blender --background --python terrain_scatter.py -- --box-rocks
 blender --background --python terrain_scatter.py -- --output terrain.png
 ```
 
-Smoke does not pass `--output` or `--skip-decimate`.
+Smoke passes no flags.
 
 ## Exit codes
 
 File-local. `9` is a valid check code. `10` is reserved for
-`gallery_framing.check_framing` on the `--output` path.
+`gallery_framing.check_framing` on the `--output` path. `15`–`19` are the
+hygiene and joint-fit family.
 
 | Code | Meaning |
 | --- | --- |
@@ -73,3 +124,8 @@ File-local. `9` is a valid check code. `10` is reserved for
 | 12 | Bake did not finish or image has no data |
 | 13 | Export file missing or empty |
 | 14 | `--output` produced no file |
+| 15 | Hygiene (`--stray-vert` lands here) |
+| 16 | Grounded zmin (`--lift-z`) |
+| 17 | Stone floor poke (`--poke-rock`) |
+| 18 | Float above host (`--float-rocks`) |
+| 19 | Stone shell faces (`--box-rocks`) |
diff --git a/showcase/terrain-scatter/preview.webp b/showcase/terrain-scatter/preview.webp
index 0ff73df..8325bc5 100644
Binary files a/showcase/terrain-scatter/preview.webp and b/showcase/terrain-scatter/preview.webp differ
diff --git a/showcase/terrain-scatter/terrain_scatter.py b/showcase/terrain-scatter/terrain_scatter.py
index 949e762..6ba8615 100644
--- a/showcase/terrain-scatter/terrain_scatter.py
+++ b/showcase/terrain-scatter/terrain_scatter.py
@@ -1,19 +1,23 @@
 """Game-ready GN terrain scatter — a showcase piece, not an example.
 
 Asserts budget conformance of a Geometry Nodes hill grid with instanced
-masonry rocks after composing shipped pipeline pieces: GN construction,
+rocks after composing shipped pipeline pieces: GN construction,
 UVs, two materials, high-to-low normal bake, LOD chain, convex collider,
 Unity glTF export.
 
+GN still builds the sine hill and the Index-jittered instance grid.
+Realized cubes are replaced with closed-form displaced icospheres seated
+on sampled dirt Z, then clamped above the slab floor.
+
 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`` LOD, ``--stray-vert`` hygiene, ``--lift-z``
+zmin, ``--poke-rock`` stone floor, ``--float-rocks`` seat, ``--box-rocks``
+stone shell faces.
 
 No RNG. Hills are a closed-form sine product; scatter is an Index-jittered
-instance grid. Realized cubes are replaced with bevelled lumped boxes
-(campfire/well masonry, not icospheres). DECIMATE COLLAPSE triangle
-counts are not byte-identical across Blender versions — the LOD gate is
-a ratio band, not an exact count.
+instance grid. DECIMATE COLLAPSE triangle counts are not byte-identical
+across Blender versions — the LOD gate is a ratio band, not an exact count.
 
     blender --background --python terrain_scatter.py --
     blender --background --python terrain_scatter.py -- --skip-decimate
@@ -44,11 +48,14 @@
 ROCK_GRID = 3
 ROCK_SPAN = 1.15
 SLAB_LIFT = 0.10
-
-BBOX_TOL = 0.01
-OUTER_SIZE = (1.800, 1.800, 0.655)
-BASE_TRIS_MIN = 1150
-BASE_TRIS_MAX = 1250
+ROCK_BITE = 0.035
+ROCK_ZMIN = 0.012
+N_ROCKS = 9
+
+BBOX_TOL = 0.015
+OUTER_SIZE = (1.800, 1.800, 0.552)
+BASE_TRIS_MIN = 1400
+BASE_TRIS_MAX = 2800
 LOD1_RATIO_MIN = 0.32
 LOD1_RATIO_MAX = 0.62
 LOD2_RATIO_MIN = 0.10
@@ -58,10 +65,20 @@
 MATERIAL_COUNT = 2
 UV_EPS = 1e-4
 UV_OVERLAP_MAX = 1e-5
-COLLIDER_TRIS_MAX = 80
+COLLIDER_TRIS_MAX = 120
 BAKE_RES = 256
 CAGE_EXTRUSION = 0.08
 STONE_FACES_MIN = 24
+STONE_SHELL_FACES_MIN = 40
+ZMIN_EPS = 1e-4
+DOUBLES_EPS = 1e-5
+AREA_EPS = 1e-10
+ZFIGHT_EPS = 1e-4
+ZFIGHT_COS = 0.998
+ROCK_SEAT_MAX = 0.02
+FLOAT_LIFT = 0.12
+POKE_BITE = 0.22
+LIFT_Z = 0.05
 
 DIRT_IDX = 0
 STONE_IDX = 1
@@ -233,7 +250,7 @@ def build_scatter_tree(verts, dirt, stone):
     tree.links.new(jx.outputs[0], jxs.inputs[0])
     jxm = tree.nodes.new("ShaderNodeMath")
     jxm.operation = "MULTIPLY"
-    jxm.inputs[1].default_value = 0.09
+    jxm.inputs[1].default_value = 0.22
     tree.links.new(jxs.outputs[0], jxm.inputs[0])
     jy = tree.nodes.new("ShaderNodeMath")
     jy.operation = "MULTIPLY"
@@ -244,7 +261,7 @@ def build_scatter_tree(verts, dirt, stone):
     tree.links.new(jy.outputs[0], jyc.inputs[0])
     jym = tree.nodes.new("ShaderNodeMath")
     jym.operation = "MULTIPLY"
-    jym.inputs[1].default_value = 0.09
+    jym.inputs[1].default_value = 0.22
     tree.links.new(jyc.outputs[0], jym.inputs[0])
     extra = tree.nodes.new("ShaderNodeMath")
     extra.operation = "ADD"
@@ -356,7 +373,64 @@ def slabify(bm, floor_z=0.0):
             f.material_index = DIRT_IDX
 
 
-def masonry_from_cubes(bm, lump, bevel_offset, bevel_segments):
+def nearest_dirt_z(bm, x, y):
+    best_z = None
+    best_d = 1e9
+    for v in bm.verts:
+        if not v.link_faces:
+            continue
+        if not any(f.material_index == DIRT_IDX for f in v.link_faces):
+            continue
+        dx = v.co.x - x
+        dy = v.co.y - y
+        d = dx * dx + dy * dy
+        if d < best_d:
+            best_d = d
+            best_z = v.co.z
+    return 0.0 if best_z is None else best_z
+
+
+def add_seated_stone(bm, cx, cy, dirt_z, box_rocks, poke, float_up):
+    sx = 0.11 + 0.025 * math.sin(cx * 8.1)
+    sy = 0.10 + 0.022 * math.cos(cy * 6.4)
+    sz = 0.075 + 0.020 * math.sin(cx * 4.2 + cy * 3.1)
+    bite = POKE_BITE if poke else ROCK_BITE
+    seat = dirt_z + FLOAT_LIFT if float_up else dirt_z - bite
+    rot = Euler(
+        (
+            0.22 * math.sin(cx * 3.1),
+            0.18 * math.cos(cy * 2.7),
+            cx * 2.4 + cy * 1.6,
+        )
+    ).to_matrix()
+    if box_rocks:
+        verts = add_box(bm, (0.0, 0.0, 0.0), (sx * 2.0, sy * 2.0, sz * 2.0), STONE_IDX)
+        for v in verts:
+            v.co = rot @ v.co
+    else:
+        geo = bmesh.ops.create_icosphere(bm, subdivisions=2, radius=1.0)
+        verts = geo["verts"]
+        for v in verts:
+            p = Vector((v.co.x * sx, v.co.y * sy, v.co.z * sz))
+            if p.length > 1e-8:
+                bump = 0.016 * math.sin(p.x * 26.0 + cx * 5.0) * math.cos(
+                    p.y * 21.0 + cy * 4.0
+                )
+                p += p.normalized() * bump
+            v.co = rot @ p
+        for f in {face for v in verts for face in v.link_faces}:
+            f.material_index = STONE_IDX
+    zmin = min(v.co.z for v in verts)
+    dz = seat - zmin
+    for v in verts:
+        v.co.x += cx
+        v.co.y += cy
+        v.co.z += dz
+        if not poke and v.co.z < ROCK_ZMIN:
+            v.co.z = ROCK_ZMIN
+
+
+def masonry_from_cubes(bm, box_rocks=False, poke=False, float_up=False):
     stone_faces = [f for f in bm.faces if f.material_index == STONE_IDX]
     visited = set()
     islands = []
@@ -382,19 +456,9 @@ def masonry_from_cubes(bm, lump, bevel_offset, bevel_segments):
         verts = {v for f in island for v in f.verts}
         xs = [v.co.x for v in verts]
         ys = [v.co.y for v in verts]
-        zs = [v.co.z for v in verts]
         cx = 0.5 * (min(xs) + max(xs))
         cy = 0.5 * (min(ys) + max(ys))
-        cz = 0.5 * (min(zs) + max(zs))
-        z0 = min(zs)
-        sx = 0.17 + 0.04 * math.sin(cx * 8.1)
-        sy = 0.15 + 0.03 * math.cos(cy * 6.4)
-        sz = 0.20 + 0.05 * math.sin(cx * 4.2 + cy * 3.1)
-        ex = 0.38 * math.sin(cx * 5.1)
-        ey = 0.30 * math.cos(cy * 4.3)
-        ez = cx * 3.7 + cy * 2.1
-        cz = z0 + sz * 0.30
-        specs.append((cx, cy, cz, sx, sy, sz, ex, ey, ez))
+        specs.append((cx, cy))
 
     if stone_faces:
         bmesh.ops.delete(bm, geom=stone_faces, context="FACES")
@@ -402,31 +466,22 @@ def masonry_from_cubes(bm, lump, bevel_offset, bevel_segments):
         if loose:
             bmesh.ops.delete(bm, geom=loose, context="VERTS")
 
-    for cx, cy, cz, sx, sy, sz, ex, ey, ez in specs:
-        verts = add_box(
-            bm,
-            (cx, cy, cz),
-            (sx, sy, sz),
-            STONE_IDX,
-            euler=(ex, ey, ez),
-        )
-        if bevel_offset > 0.0:
-            edges = list({e for v in verts for e in v.link_edges})
-            if edges:
-                ret = bmesh.ops.bevel(
-                    bm,
-                    geom=edges,
-                    offset=bevel_offset,
-                    segments=bevel_segments,
-                    profile=0.5,
-                    affect="EDGES",
-                    clamp_overlap=True,
-                )
-                for f in ret.get("faces") or []:
-                    f.material_index = STONE_IDX
-
-
-def build_terrain_mesh(name, grid_verts, lump, bevel_offset, bevel_segments, dirt, stone):
+    bm.verts.ensure_lookup_table()
+    bm.faces.ensure_lookup_table()
+    for cx, cy in specs:
+        dirt_z = nearest_dirt_z(bm, cx, cy)
+        add_seated_stone(bm, cx, cy, dirt_z, box_rocks, poke, float_up)
+
+
+def build_terrain_mesh(
+    name,
+    grid_verts,
+    dirt,
+    stone,
+    box_rocks=False,
+    poke=False,
+    float_up=False,
+):
     carrier = bpy.data.meshes.new(name + "Carrier")
     carrier.vertices.add(1)
     obj = bpy.data.objects.new(name + "GN", carrier)
@@ -446,7 +501,7 @@ def build_terrain_mesh(name, grid_verts, lump, bevel_offset, bevel_segments, dir
         slabify(bm, floor_z=0.0)
         bm.verts.ensure_lookup_table()
         bm.faces.ensure_lookup_table()
-        masonry_from_cubes(bm, lump, bevel_offset, bevel_segments)
+        masonry_from_cubes(bm, box_rocks=box_rocks, poke=poke, float_up=float_up)
         xs = [v.co.x for v in bm.verts]
         ys = [v.co.y for v in bm.verts]
         zs = [v.co.z for v in bm.verts]
@@ -459,15 +514,18 @@ def build_terrain_mesh(name, grid_verts, lump, bevel_offset, bevel_segments, dir
             v.co.z -= zmin
             if v.co.z < 0.0:
                 v.co.z = 0.0
+        ngons = [f for f in bm.faces if len(f.verts) > 4]
+        if ngons:
+            bmesh.ops.triangulate(bm, faces=ngons)
         pack_uvs(bm)
         bmesh.ops.recalc_face_normals(bm, faces=list(bm.faces))
         for face in bm.faces:
-            face.smooth = False
+            face.smooth = face.material_index == STONE_IDX
         me = bpy.data.meshes.new(name)
         bm.to_mesh(me)
         me.update()
         for poly in me.polygons:
-            poly.use_smooth = False
+            poly.use_smooth = poly.material_index == STONE_IDX
     finally:
         bm.free()
     out = bpy.data.objects.new(name, me)
@@ -475,13 +533,25 @@ def build_terrain_mesh(name, grid_verts, lump, bevel_offset, bevel_segments, dir
     return out
 
 
-def principled(name, color, metallic, roughness):
+def principled(name, color, metallic, roughness, noise_scale=0.0, wear=None):
     mat = bpy.data.materials.new(name)
     mat.use_nodes = True
-    bsdf = mat.node_tree.nodes["Principled BSDF"]
+    nt = mat.node_tree
+    bsdf = nt.nodes["Principled BSDF"]
     bsdf.inputs["Base Color"].default_value = color
     bsdf.inputs["Metallic"].default_value = metallic
     bsdf.inputs["Roughness"].default_value = roughness
+    if noise_scale > 0.0 and wear is not None:
+        tex = nt.nodes.new("ShaderNodeTexNoise")
+        tex.inputs["Scale"].default_value = noise_scale
+        tex.inputs["Detail"].default_value = 6.0
+        mix = nt.nodes.new("ShaderNodeMix")
+        mix.data_type = "RGBA"
+        mix.inputs["A"].default_value = color
+        mix.inputs["B"].default_value = wear
+        fac = mix.inputs.get("Factor") or mix.inputs.get("Fac")
+        nt.links.new(tex.outputs["Fac"], fac)
+        nt.links.new(mix.outputs["Result"], bsdf.inputs["Base Color"])
     return mat
 
 
@@ -498,10 +568,11 @@ def assign_slots(obj, dirt, stone):
 
 
 def world_bbox(obj):
-    corners = [obj.matrix_world @ Vector(c) for c in obj.bound_box]
-    xs = [c.x for c in corners]
-    ys = [c.y for c in corners]
-    zs = [c.z for c in corners]
+    mat = obj.matrix_world
+    pts = [mat @ v.co for v in obj.data.vertices]
+    xs = [p.x for p in pts]
+    ys = [p.y for p in pts]
+    zs = [p.z for p in pts]
     return (min(xs), min(ys), min(zs), max(xs), max(ys), max(zs))
 
 
@@ -616,15 +687,187 @@ def export_unity(path, objects):
     )
 
 
-def check(skip_decimate):
+def face_area(me, poly):
+    vs = [me.vertices[i].co for i in poly.vertices]
+    if len(vs) < 3:
+        return 0.0
+    v0 = vs[0]
+    area = 0.0
+    for i in range(1, len(vs) - 1):
+        area += (vs[i] - v0).cross(vs[i + 1] - v0).length * 0.5
+    return area
+
+
+def hygiene_audit(me):
+    nv, ne, nf = len(me.vertices), len(me.edges), len(me.polygons)
+    ngons = sum(1 for p in me.polygons if len(p.vertices) > 4)
+    zero_area = sum(1 for p in me.polygons if face_area(me, p) <= AREA_EPS)
+    bm = bmesh.new()
+    try:
+        bm.from_mesh(me)
+        loose_v = sum(1 for v in bm.verts if len(v.link_edges) == 0)
+        loose_e = sum(1 for e in bm.edges if len(e.link_faces) == 0)
+        nonman = sum(1 for e in bm.edges if not e.is_manifold)
+        ret = bmesh.ops.find_doubles(bm, verts=list(bm.verts), dist=DOUBLES_EPS)
+        doubles = len(ret.get("targetmap") or {})
+    finally:
+        bm.free()
+    return {
+        "nv": nv, "ne": ne, "nf": nf, "ngons": ngons,
+        "loose_v": loose_v, "loose_e": loose_e, "nonman": nonman,
+        "zero_area": zero_area, "doubles": doubles, "euler": nv - ne + nf,
+    }
+
+
+def zfight_pairs(me):
+    data = [
+        (p.center.copy(), p.normal.copy(), frozenset(p.vertices))
+        for p in me.polygons
+    ]
+    eps2 = ZFIGHT_EPS * ZFIGHT_EPS
+    count = 0
+    for i in range(len(data)):
+        ci, ni, vi = data[i]
+        for j in range(i + 1, len(data)):
+            cj, nj, vj = data[j]
+            if (cj - ci).length_squared > eps2:
+                continue
+            if abs(ni.dot(nj)) <= ZFIGHT_COS:
+                continue
+            if vi & vj:
+                continue
+            count += 1
+    return count
+
+
+def shells(me):
+    neighbors = [[] for _ in range(len(me.vertices))]
+    for edge in me.edges:
+        a, b = edge.vertices
+        neighbors[a].append(b)
+        neighbors[b].append(a)
+    seen = [False] * len(me.vertices)
+    groups = []
+    for start in range(len(me.vertices)):
+        if seen[start]:
+            continue
+        seen[start] = True
+        stack = [start]
+        group = []
+        while stack:
+            current = stack.pop()
+            group.append(current)
+            for nxt in neighbors[current]:
+                if not seen[nxt]:
+                    seen[nxt] = True
+                    stack.append(nxt)
+        groups.append(group)
+    return groups
+
+
+def shell_aabb(me, group):
+    pts = [me.vertices[i].co for i in group]
+    return (
+        min(p.x for p in pts), min(p.y for p in pts), min(p.z for p in pts),
+        max(p.x for p in pts), max(p.y for p in pts), max(p.z for p in pts),
+    )
+
+
+def mat_of(me, group):
+    member = set(group)
+    for poly in me.polygons:
+        if all(i in member for i in poly.vertices):
+            return poly.material_index
+    return None
+
+
+def shell_faces(me, group):
+    member = set(group)
+    return sum(1 for p in me.polygons if all(i in member for i in p.vertices))
+
+
+def add_stray_vert(me):
+    bm = bmesh.new()
+    try:
+        bm.from_mesh(me)
+        bm.verts.new((0.0, 0.0, 0.55))
+        bm.to_mesh(me)
+        me.update()
+    finally:
+        bm.free()
+
+
+def nearest_mesh_dirt_z(me, x, y, dirt_verts):
+    best_z = 0.0
+    best_d = 1e9
+    for co in dirt_verts:
+        d = (co.x - x) ** 2 + (co.y - y) ** 2
+        if d < best_d:
+            best_d = d
+            best_z = co.z
+    return best_z
+
+
+def joint_audit(me):
+    groups = shells(me)
+    stones = []
+    dirt_verts = []
+    for poly in me.polygons:
+        if poly.material_index != DIRT_IDX:
+            continue
+        for i in poly.vertices:
+            dirt_verts.append(me.vertices[i].co)
+    for g in groups:
+        if mat_of(me, g) != STONE_IDX:
+            continue
+        a = shell_aabb(me, g)
+        nfaces = shell_faces(me, g)
+        cx = 0.5 * (a[0] + a[3])
+        cy = 0.5 * (a[1] + a[4])
+        dirt_z = nearest_mesh_dirt_z(me, cx, cy, dirt_verts)
+        stones.append((a[2], nfaces, a[2] - dirt_z))
+    n_stones = len(stones)
+    min_faces = min((s[1] for s in stones), default=0)
+    poke_z = min((s[0] for s in stones), default=99.0)
+    float_off = max((s[2] for s in stones), default=0.0)
+    return {
+        "n_stones": n_stones,
+        "min_faces": min_faces,
+        "poke_z": poke_z,
+        "float_off": float_off,
+    }
+
+
+def check(
+    skip_decimate,
+    lift_z=False,
+    stray_vert=False,
+    poke=False,
+    float_up=False,
+    box_rocks=False,
+):
     bpy.ops.wm.read_factory_settings(use_empty=True)
-    dirt = principled("TerrainDirt", (0.30, 0.17, 0.07, 1.0), 0.0, 0.90)
-    stone = principled("TerrainStone", (0.56, 0.53, 0.48, 1.0), 0.0, 0.76)
-    low = build_terrain_mesh("TerrainLow", 9, 0.10, 0.022, 2, dirt, stone)
-    high = build_terrain_mesh("TerrainHigh", 13, 0.10, 0.022, 4, dirt, stone)
+    dirt = principled(
+        "TerrainDirt", (0.30, 0.17, 0.07, 1.0), 0.0, 0.90,
+        noise_scale=14.0, wear=(0.18, 0.10, 0.04, 1.0),
+    )
+    stone = principled(
+        "TerrainStone", (0.56, 0.53, 0.48, 1.0), 0.0, 0.76,
+        noise_scale=20.0, wear=(0.38, 0.35, 0.30, 1.0),
+    )
+    kw = dict(box_rocks=box_rocks, poke=poke, float_up=float_up)
+    low = build_terrain_mesh("TerrainLow", 21, dirt, stone, **kw)
+    high = build_terrain_mesh("TerrainHigh", 25, dirt, stone, **kw)
     assign_slots(low, dirt, stone)
     assign_slots(high, dirt, stone)
 
+    if stray_vert:
+        add_stray_vert(low.data)
+    if lift_z:
+        for v in low.data.vertices:
+            v.co.z += LIFT_Z
+        low.data.update()
+
     if low.data is None or len(low.data.polygons) < 6:
         return fail("terrain mesh did not build", 3), None, None, None, None, None
 
@@ -656,7 +899,7 @@ def check(skip_decimate):
     r2 = lod2_tris / base_tris if base_tris else 0.0
 
     collider_src = build_terrain_mesh(
-        "TerrainColSrc", 9, 0.0, 0.0, 1, dirt, stone
+        "TerrainColSrc", 21, dirt, stone, **kw
     )
     collider = convex_hull_collider(collider_src, "TerrainCollider")
     bpy.data.objects.remove(collider_src, do_unlink=True)
@@ -688,7 +931,24 @@ def check(skip_decimate):
         f"measured collider_tris={col_tris} bake={bake_result} "
         f"bake_has_data={img.has_data} export_bytes={export_size}"
     )
+    hyg = hygiene_audit(low.data)
+    zf = zfight_pairs(low.data)
+    jnt = joint_audit(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 stones={jnt['n_stones']} min_faces={jnt['min_faces']} "
+        f"poke_z={jnt['poke_z']:.5f} float_off={jnt['float_off']:.5f}"
+    )
 
+    if jnt["min_faces"] < STONE_SHELL_FACES_MIN:
+        return fail(
+            f"stone shell faces {jnt['min_faces']} < {STONE_SHELL_FACES_MIN}",
+            19,
+        ), None, None, None, None, None
     if not (BASE_TRIS_MIN <= base_tris <= BASE_TRIS_MAX):
         return fail(
             f"base tris {base_tris} not in [{BASE_TRIS_MIN}, {BASE_TRIS_MAX}]",
@@ -714,6 +974,18 @@ def check(skip_decimate):
             f"UV AABB overlap {overlap:.6f} > {UV_OVERLAP_MAX}",
             7,
         ), None, None, None, None, None
+    if jnt["n_stones"] != N_ROCKS or jnt["poke_z"] < ROCK_ZMIN:
+        return fail(
+            f"poke stones={jnt['n_stones']} poke_z={jnt['poke_z']:.5f}",
+            17,
+        ), None, None, None, None, None
+    if jnt["float_off"] > ROCK_SEAT_MAX:
+        return fail(
+            f"float_off {jnt['float_off']:.5f} > {ROCK_SEAT_MAX}",
+            18,
+        ), None, None, None, None, None
+    if bb[2] > ZMIN_EPS:
+        return fail(f"grounded zmin={bb[2]:.5f}", 16), None, None, None, None, None
     if (
         abs(size_x - OUTER_SIZE[0]) > BBOX_TOL
         or abs(size_y - OUTER_SIZE[1]) > BBOX_TOL
@@ -747,6 +1019,16 @@ def check(skip_decimate):
         ), None, None, None, None, None
     if export_size <= 0:
         return fail("export file missing or empty", 13), None, None, None, None, None
+    if (
+        hyg["loose_v"] or hyg["loose_e"] or hyg["nonman"] or hyg["zero_area"]
+        or hyg["doubles"] or hyg["ngons"] or zf
+    ):
+        return fail(
+            f"hygiene loose_v={hyg['loose_v']} loose_e={hyg['loose_e']} "
+            f"nonman={hyg['nonman']} zero_area={hyg['zero_area']} "
+            f"doubles={hyg['doubles']} ngons={hyg['ngons']} zfight={zf}",
+            15,
+        ), None, None, None, None, None
     return 0, low, high, dirt, tex, collider
 
 
@@ -860,14 +1142,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("--poke-rock", action="store_true")
+    p.add_argument("--float-rocks", action="store_true")
+    p.add_argument("--box-rocks", action="store_true")
     args = p.parse_args(argv)
 
-    code, low, _high, dirt, tex, _col = check(args.skip_decimate)
+    code, low, _high, dirt, tex, _col = check(
+        args.skip_decimate,
+        lift_z=args.lift_z,
+        stray_vert=args.stray_vert,
+        poke=args.poke_rock,
+        float_up=args.float_rocks,
+        box_rocks=args.box_rocks,
+    )
     if code:
         return code
     if args.output: