diff --git a/docs/gallery/assets/attribute-domain-shear-hero.webp b/docs/gallery/assets/attribute-domain-shear-hero.webp
index 6bf8f32f..ab0dc255 100644
Binary files a/docs/gallery/assets/attribute-domain-shear-hero.webp and b/docs/gallery/assets/attribute-domain-shear-hero.webp differ
diff --git a/docs/gallery/assets/cart-hero.webp b/docs/gallery/assets/cart-hero.webp
index 28b5a011..4d9cb65d 100644
Binary files a/docs/gallery/assets/cart-hero.webp and b/docs/gallery/assets/cart-hero.webp differ
diff --git a/docs/gallery/assets/grindstone-hero.webp b/docs/gallery/assets/grindstone-hero.webp
index 1b323765..1f15752f 100644
Binary files a/docs/gallery/assets/grindstone-hero.webp and b/docs/gallery/assets/grindstone-hero.webp differ
diff --git a/docs/gallery/attribute-domain-shear/index.html b/docs/gallery/attribute-domain-shear/index.html
index 6aac9592..114d9b6f 100644
--- a/docs/gallery/attribute-domain-shear/index.html
+++ b/docs/gallery/attribute-domain-shear/index.html
@@ -16,13 +16,13 @@
   <meta property="og:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/attribute-domain-shear-hero.webp" />
   <meta property="og:image:width" content="1280" />
   <meta property="og:image:height" content="720" />
-  <meta property="og:image:alt" content="Two octagonal rainbow-coloured caps labelled CORNER and POINT, last write wins, showing different colour blending." />
+  <meta property="og:image:alt" content="Two rainbow pinwheels on wooden sticks, well apart: CORNER on the left with crisp coloured petals, POINT, last write wins, on the right with colours smeared across the hub." />
   <meta property="og:site_name" content="Blender Developer Tools" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="attribute-domain-shear — Examples — Blender Developer Tools" />
   <meta name="twitter:description" content="POINT vs CORNER color-attribute domains on a shared-vertex pinwheel: CORNER stays exact per face while a naive per-wedge POINT loop shears to the last write at the hub. Crisp petals versus a smeared swirl in one frame; the measured shear equals the palette closed form." />
   <meta name="twitter:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/attribute-domain-shear-hero.webp" />
-  <meta name="twitter:image:alt" content="Two octagonal rainbow-coloured caps labelled CORNER and POINT, last write wins, showing different colour blending." />
+  <meta name="twitter:image:alt" content="Two rainbow pinwheels on wooden sticks, well apart: CORNER on the left with crisp coloured petals, POINT, last write wins, on the right with colours smeared across the hub." />
   <style>
     /* fonts are deployed by the landing build (docs/fonts/) */
     @font-face { font-family: 'Barlow Condensed'; font-weight: 600; font-display: swap;
@@ -268,8 +268,8 @@ <h1>attribute-domain-shear</h1>
     <p>POINT vs CORNER color-attribute domains on a shared-vertex pinwheel: CORNER stays exact per face while a naive per-wedge POINT loop shears to the last write at the hub. Crisp petals versus a smeared swirl in one frame; the measured shear equals the palette closed form.</p>
   </header>
   <main id="main">
-    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: Two octagonal rainbow-coloured caps labelled CORNER and POINT, last write wins, showing different colour blending.">
-      <img src="../assets/attribute-domain-shear-hero.webp" alt="Two octagonal rainbow-coloured caps labelled CORNER and POINT, last write wins, showing different colour blending." width="1280" height="720" />
+    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: Two rainbow pinwheels on wooden sticks, well apart: CORNER on the left with crisp coloured petals, POINT, last write wins, on the right with colours smeared across the hub.">
+      <img src="../assets/attribute-domain-shear-hero.webp" alt="Two rainbow pinwheels on wooden sticks, well apart: CORNER on the left with crisp coloured petals, POINT, last write wins, on the right with colours smeared across the hub." 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> Authoring per-face colors into a POINT-domain attribute overwrites shared vertices once per neighbor; the last write wins and intended colors shear across every shared vertex.</div>
@@ -285,6 +285,7 @@ <h1>attribute-domain-shear</h1>
 <p><strong>What each check catches on failure:</strong> wedge 3 miscolored in the CORNER pass (exit 4); naive writes reversed, so the hub reads palette[0] (exit 5); a ring vert corrupted, breaking the overwrite-ordering witness (exit 6); a constant palette, collapsing the shear so the probe cannot distinguish naive from correct (exit 7). Sizes wrong for the declared domain (exit 3).</p>
 <p><strong>Version witness:</strong> output is byte-identical on Blender 4.5.11 LTS and 5.1.2 — the <code>color_attributes</code> domain API is stable across both.</p>
 <p><strong>Render as proof:</strong> dual pinwheel from the same closed-form palette the check asserts. CORNER (left) holds eight crisp petals to the hub; naive POINT (right) smears — petal colors bleed across the shared hub and ring verts into a swirl. The broken state is in-frame by design: the right fan <em>is</em> the falsification variant. Fully matte petal materials (<code>Specular IOR Level = 0</code>) so the flat color data carries no specular line, per <code>docs/VISUAL-STYLE.md</code>.</p>
+<p>The staging is render-only and does not touch the checked mesh. The two stands are 2.72 m apart so their canopies read as two objects; at 2.30 m the petal tips met at the centre of the frame. Each stand&#x27;s wooden stick runs from just below the floor into the hub it carries, both ends derived from the stand&#x27;s tilt. The old dark steel stick stopped 0.6 m short of the hub, under the canopy, and disappeared into the stage.</p>
 <h2>Run</h2>
 <pre><code>blender --background --python attribute_domain_shear.py --
 blender --background --python attribute_domain_shear.py -- --no-overwrite
@@ -519,26 +520,37 @@ <h2>Source</h2>
     <span class="k">return</span> mat
 
 
+STAND_TILT = math.radians(<span class="n">12</span>)
+STEM_BURY = <span class="n">0.02</span>
+
+
 <span class="k">def</span> _pinwheel_obj(sc, name, me, loc, rot_z):
     ob = bpy.data.objects.new(name, me)
     ob.location = loc
-    ob.rotation_euler = (math.radians(<span class="n">12</span>), <span class="n">0.0</span>, rot_z)
+    ob.rotation_euler = (STAND_TILT, <span class="n">0.0</span>, rot_z)
     sc.collection.objects.link(ob)
-    <span class="c"># stem + hub cap: a garden pinwheel on a stick, not a floating disc</span>
+    <span class="c"># stem + hub cap: a garden pinwheel on a stick, not a floating disc. The</span>
+    <span class="c"># stick runs from just under the floor to the hub it carries, both ends</span>
+    <span class="c"># derived from the stand&#x27;s own tilt; it used to stop 0.6 below the hub,</span>
+    <span class="c"># hidden under the canopy, holding nothing.</span>
+    stem_lo = -(loc[<span class="n">2</span>] / math.cos(STAND_TILT)) - STEM_BURY
+    stem_hi = HUB_Z
     stem_me = bpy.data.meshes.new(name + <span class="s">&quot;Stem&quot;</span>)
     bm = bmesh.new()
     <span class="k">try</span>:
-        bmesh.ops.create_cone(bm, cap_ends=<span class="k">True</span>, segments=<span class="n">10</span>, radius1=<span class="n">0.05</span>,
-                              radius2=<span class="n">0.06</span>, depth=<span class="n">1.35</span>)
-        bmesh.ops.translate(bm, vec=(<span class="n">0.0</span>, <span class="n">0.0</span>, -<span class="n">0.72</span>), verts=bm.verts)
+        bmesh.ops.create_cone(bm, cap_ends=<span class="k">True</span>, segments=<span class="n">10</span>, radius1=<span class="n">0.045</span>,
+                              radius2=<span class="n">0.035</span>, depth=stem_hi - stem_lo)
+        bmesh.ops.translate(bm, vec=(<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.5</span> * (stem_lo + stem_hi)),
+                            verts=bm.verts)
         bm.to_mesh(stem_me)
     <span class="k">finally</span>:
         bm.free()
-    stem_me.materials.append(make_material(<span class="s">&quot;StemMetal&quot;</span>, (<span class="n">0.16</span>, <span class="n">0.17</span>, <span class="n">0.18</span>),
-                                           rough=<span class="n">0.4</span>, metallic=<span class="n">0.8</span>))
+    <span class="c"># a painted wooden dowel: near-black steel vanished into the dark stage</span>
+    stem_me.materials.append(make_material(<span class="s">&quot;StemDowel&quot;</span>, (<span class="n">0.46</span>, <span class="n">0.30</span>, <span class="n">0.16</span>),
+                                           rough=<span class="n">0.55</span>, metallic=<span class="n">0.0</span>))
     stem = bpy.data.objects.new(name + <span class="s">&quot;Stem&quot;</span>, stem_me)
     stem.location = loc
-    stem.rotation_euler = (math.radians(<span class="n">12</span>), <span class="n">0.0</span>, rot_z)
+    stem.rotation_euler = (STAND_TILT, <span class="n">0.0</span>, rot_z)
     sc.collection.objects.link(stem)
     cap_me = bpy.data.meshes.new(name + <span class="s">&quot;Cap&quot;</span>)
     bm = bmesh.new()
@@ -552,7 +564,7 @@ <h2>Source</h2>
                                           rough=<span class="n">0.35</span>, metallic=<span class="n">0.85</span>))
     cap = bpy.data.objects.new(name + <span class="s">&quot;Cap&quot;</span>, cap_me)
     cap.location = loc
-    cap.rotation_euler = (math.radians(<span class="n">12</span>), <span class="n">0.0</span>, rot_z)
+    cap.rotation_euler = (STAND_TILT, <span class="n">0.0</span>, rot_z)
     sc.collection.objects.link(cap)
     <span class="k">return</span> ob
 
@@ -611,6 +623,9 @@ <h2>Source</h2>
     <span class="k">return</span> floor, wall
 
 
+PAIR_X = <span class="n">1.36</span>
+
+
 <span class="k">def</span> render_still(path, engine):
     <span class="s">&quot;&quot;&quot;Dual pinwheel: CORNER (crisp petals to the hub) vs naive POINT (last
     write smears the shared hub + ring verts). Colors come from the same
@@ -622,20 +637,22 @@ <h2>Source</h2>
     me_c = build_fan()
     assign_corner(me_c, pal)
     me_c.materials.append(make_attr_material(<span class="s">&quot;MatCorner&quot;</span>, ATTR_C))
-    left = _pinwheel_obj(sc, <span class="s">&quot;Corner&quot;</span>, me_c, (-<span class="n">1.15</span>, <span class="n">0.0</span>, <span class="n">1.35</span>), math.radians(-<span class="n">8</span>))
+    <span class="c"># Spread so the two canopies read as two objects: at +/-1.15 their</span>
+    <span class="c"># tips met at x=0 and the pair read as one shape.</span>
+    left = _pinwheel_obj(sc, <span class="s">&quot;Corner&quot;</span>, me_c, (-PAIR_X, <span class="n">0.0</span>, <span class="n">1.35</span>), math.radians(-<span class="n">8</span>))
 
     me_p = build_fan()
     assign_point_naive(me_p, pal)
     me_p.materials.append(make_attr_material(<span class="s">&quot;MatPoint&quot;</span>, ATTR_P))
-    right = _pinwheel_obj(sc, <span class="s">&quot;Point&quot;</span>, me_p, (<span class="n">1.15</span>, <span class="n">0.0</span>, <span class="n">1.35</span>), math.radians(<span class="n">8</span>))
+    right = _pinwheel_obj(sc, <span class="s">&quot;Point&quot;</span>, me_p, (PAIR_X, <span class="n">0.0</span>, <span class="n">1.35</span>), math.radians(<span class="n">8</span>))
 
-    p_corner = placard(sc, <span class="s">&quot;CORNER&quot;</span>, (-<span class="n">1.15</span>, -<span class="n">1.05</span>, <span class="n">0.02</span>), size=<span class="n">0.13</span>)
-    p_point = placard(sc, <span class="s">&quot;POINT — last write wins&quot;</span>, (<span class="n">1.15</span>, -<span class="n">1.05</span>, <span class="n">0.02</span>), size=<span class="n">0.10</span>)
+    p_corner = placard(sc, <span class="s">&quot;CORNER&quot;</span>, (-PAIR_X, -<span class="n">1.05</span>, <span class="n">0.02</span>), size=<span class="n">0.13</span>)
+    p_point = placard(sc, <span class="s">&quot;POINT — last write wins&quot;</span>, (PAIR_X, -<span class="n">1.05</span>, <span class="n">0.02</span>), size=<span class="n">0.10</span>)
 
     floor, wall = build_studio(sc)
 
     cam_data = bpy.data.cameras.new(<span class="s">&quot;Cam&quot;</span>)
-    cam_data.lens = <span class="n">48.0</span>
+    cam_data.lens = <span class="n">44.0</span>
     cam = bpy.data.objects.new(<span class="s">&quot;Cam&quot;</span>, cam_data)
     cam.location = (<span class="n">0.0</span>, -<span class="n">6.4</span>, <span class="n">4.6</span>)
     sc.collection.objects.link(cam)
@@ -722,7 +739,7 @@ <h2>Source</h2>
   </main>
   <dialog class="lightbox" id="lightbox" aria-label="Full-size render">
     <button class="lightbox-close" type="button" autofocus>Close</button>
-    <img src="../assets/attribute-domain-shear-hero.webp" alt="Two octagonal rainbow-coloured caps labelled CORNER and POINT, last write wins, showing different colour blending." />
+    <img src="../assets/attribute-domain-shear-hero.webp" alt="Two rainbow pinwheels on wooden sticks, well apart: CORNER on the left with crisp coloured petals, POINT, last write wins, on the right with colours smeared across the hub." />
   </dialog>
   <footer>
     <div class="statusbar">
diff --git a/docs/gallery/cart/index.html b/docs/gallery/cart/index.html
index 795a94d8..a7bfebe3 100644
--- a/docs/gallery/cart/index.html
+++ b/docs/gallery/cart/index.html
@@ -4,25 +4,25 @@
   <meta charset="utf-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1" />
   <title>cart — Showcase — Blender Developer Tools</title>
-  <meta name="description" content="A procedural two-wheel wooden cart through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
+  <meta name="description" content="A procedural two-wheel handcart 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/cart/" />
   <link rel="icon" href="../../assets/favicon.svg" type="image/svg+xml" />
   <meta name="theme-color" content="#1a1b1e" />
   <meta name="color-scheme" content="dark" />
   <meta property="og:type" content="website" />
   <meta property="og:title" content="cart — Showcase — Blender Developer Tools" />
-  <meta property="og:description" content="A procedural two-wheel wooden cart through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
+  <meta property="og:description" content="A procedural two-wheel handcart 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/cart/" />
   <meta property="og:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/cart-hero.webp" />
   <meta property="og:image:width" content="1280" />
   <meta property="og:image:height" content="720" />
-  <meta property="og:image:alt" content="A two-wheeled wooden cart with spoked wheels, an open box bed and long shafts resting on the floor." />
+  <meta property="og:image:alt" content="A wooden handcart with a planked box bed and iron corner straps on two spoked wheels, standing level on two prop legs with its shafts joined by a pull bar." />
   <meta property="og:site_name" content="Blender Developer Tools" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="cart — Showcase — Blender Developer Tools" />
-  <meta name="twitter:description" content="A procedural two-wheel wooden cart through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
+  <meta name="twitter:description" content="A procedural two-wheel handcart 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/cart-hero.webp" />
-  <meta name="twitter:image:alt" content="A two-wheeled wooden cart with spoked wheels, an open box bed and long shafts resting on the floor." />
+  <meta name="twitter:image:alt" content="A wooden handcart with a planked box bed and iron corner straps on two spoked wheels, standing level on two prop legs with its shafts joined by a pull bar." />
   <style>
     /* fonts are deployed by the landing build (docs/fonts/) */
     @font-face { font-family: 'Barlow Condensed'; font-weight: 600; font-display: swap;
@@ -265,43 +265,53 @@
   </div>
   <header class="hero">
     <h1>cart</h1>
-    <p>A procedural two-wheel wooden cart through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.</p>
+    <p>A procedural two-wheel handcart 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="View full size: A two-wheeled wooden cart with spoked wheels, an open box bed and long shafts resting on the floor.">
-      <img src="../assets/cart-hero.webp" alt="A two-wheeled wooden cart with spoked wheels, an open box bed and long shafts resting on the floor." width="1280" height="720" />
+    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: A wooden handcart with a planked box bed and iron corner straps on two spoked wheels, standing level on two prop legs with its shafts joined by a pull bar.">
+      <img src="../assets/cart-hero.webp" alt="A wooden handcart with a planked box bed and iron corner straps on two spoked wheels, standing level on two prop legs with its shafts joined by a pull bar." width="1280" height="720" />
     </button>
     <p class="zoom-hint">Rendered headless by the showcase piece itself — click to zoom.</p>
-    <div class="callout"><span class="tag">witnesses</span> Recomputed: 2856 tris, two materials with metal and wood face floors, UVs in 0..1 with zero AABB overlap, outer AABB 1.539×0.749×0.640 m, LOD ratios in band, convex collider 154 tris, hygiene zero (loose, non-manifold, doubles, n-gons), zero coplanar cross-shell face pairs, both tyres grounded, tyre seat depth in band over 48 angular stations, the two wheels mirrored within 5e-5 m, grounded zmin, non-empty glTF. --flush-tyre exits 15 on the z-fight budget; --sink-tyre exits 18 on the tyre seat band; --float-wheel exits 16 on the named-support budget; --skew-wheel exits 19 on the wheel mirror; --skip-decimate exits 9 on the LOD1 ratio budget; --lift-z exits 16 on the grounded budget.</div>
+    <div class="callout"><span class="tag">witnesses</span> Recomputed: 5284 tris, two materials with metal and wood face floors, UVs in 0..1 with zero AABB overlap, outer AABB 1.580×0.842×0.640 m, LOD ratios in band, convex collider 192 tris, hygiene zero (loose, non-manifold, doubles, n-gons), zero coplanar cross-shell face pairs, both tyres and both prop legs grounded, two wall boards per side with 3 mm seams, tyre seat depth in band over 48 angular stations, every shell in one BVH-contact assembly, the two wheels mirrored within 5e-5 m, no unchamfered right-angle edge, 17.45 bake texels per UV cell, non-empty glTF. --flush-tyre exits 15 on the z-fight budget; --float-wheel and --short-props exit 16 on the named-support budget; --wide-seams exits 17 on the board seams; --sink-tyre exits 18 on the tyre seat band; --lift-bed exits 18 on the one-assembly budget; --skew-wheel exits 19 on the wheel mirror; --sharp-bar exits 20 on edge treatment; --low-bake exits 21 on texel density; --skip-decimate exits 9 on the LOD1 ratio budget; --lift-z exits 16 on the grounded budget.</div>
     <div class="runline">
       <pre id="runCmd">blender --background --python showcase/cart/cart.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 two-wheel wooden cart (slatted bed, side walls, shafts, spoked wheels, iron hubs and axle) 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. A procedural two-wheel handcart built on two rails that run on past the bed as shafts, with a pull bar through their tips and two prop legs under them. It has a planked floor, board walls with iron corner straps, and spoked wheels on long naves with iron bands, tyres and washers. The piece then runs the shipped pipeline: unique-cell UVs, a Cycles high-to-low normal bake, an LOD chain, a convex collider, and a Unity glTF export.</p>
+<p>The chassis is stacked from the axle up, and every member bites the one below it by a named depth: axle, bolster, rails, floor planks, walls. The cart stands level on four named supports: two tyres and two legs. Stated size is 1.58 m long, 0.84 m across the axle ends and 0.64 m tall. The wheels are 0.64 m in diameter and the bed is 0.92 × 0.50 m.</p>
 <p>It asserts <strong>budget conformance</strong> of the generated result. It does not witness an API contract. &quot;It rendered without error&quot; is not a check.</p>
 <p><strong>Composes</strong> skills <code>mesh-editing-and-bmesh</code>, <code>bake-high-to-low</code>, <code>depsgraph-and-evaluated-data</code>, <code>engine-export-presets</code>, and snippets <code>bake_normal_high_to_low.py</code>, <code>setup_bake_target_image.py</code>, <code>lod_chain.py</code> / <code>decimate_to_budget.py</code>, <code>convex_hull_collider.py</code>, <code>export_preset_unity.py</code> (helpers copied, not imported as a package).</p>
 <h2>Budgets</h2>
 <p>Declared as named constants; every gate <strong>recomputes</strong> from the mesh, materials, UVs, evaluated LOD, collider, or export file.</p>
-<div class="table-wrap"><table><thead><tr><th scope="col">Axis</th><th scope="col">Declared</th><th scope="col">Measured (4.5.11 / 5.1.2 / 5.2.1)</th></tr></thead><tbody><tr><td>Base triangles</td><td>2760–2960</td><td>2856 / 2856 / 2856</td></tr><tr><td>LOD1 ratio</td><td>0.32–0.62 of base</td><td>0.5000 / 0.5000 / 0.5000</td></tr><tr><td>LOD2 ratio</td><td>0.10–0.35 of base</td><td>0.2199 / 0.2199 / 0.2157</td></tr><tr><td>Materials</td><td>exactly 2 distinct, metal ≥ 24, wood ≥ 800 faces</td><td>2 slots, floors met</td></tr><tr><td>UVs</td><td>in <code>0..1</code>, AABB overlap ≤ 1e-5</td><td>in range, overlap 0</td></tr><tr><td>Outer AABB</td><td>(1.539, 0.749, 0.640) m ± 0.01</td><td>(1.5393, 0.7486, 0.6400)</td></tr><tr><td>Grounded</td><td>bbox min Z within 1e-4 of 0</td><td>0.0000 / 0.0000 / 0.0000</td></tr><tr><td>Named supports</td><td>each tyre&#x27;s own zmin within 1e-4 of the floor</td><td>+Y 0.000000, −Y 0.000000</td></tr><tr><td>Hygiene</td><td>loose V/E, non-manifold, zero-area, doubles @1e-5, n-gons: all 0</td><td>0 / 0 / 0 on every axis</td></tr><tr><td>Z-fighting</td><td>coplanar cross-shell face pairs = 0</td><td>0 / 0 / 0</td></tr><tr><td>Tyre seat</td><td>0.0030–0.0055 m interference, per angular station</td><td>[0.00400, 0.00400] over 48 stations</td></tr><tr><td>Wheel mirror</td><td>the two wheels match in X, Z and extent within 5e-5 m</td><td>0.00000 mm</td></tr><tr><td>Material-island gap</td><td>metal↔wood min distance ≤ 0.008 m</td><td>0.00000 / 0.00000 / 0.00000</td></tr><tr><td>Collider tris</td><td>≤ 360</td><td>154</td></tr><tr><td>Export</td><td>written, size &gt; 0, removed after measuring</td><td>221960 bytes on 5.2.1</td></tr></tbody></table></div>
-<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 a few bytes across series (glTF serializer); the gate is &quot;written and non-empty&quot;, not a byte count, and the file is removed once measured.</p>
+<div class="table-wrap"><table><thead><tr><th scope="col">Axis</th><th scope="col">Declared</th><th scope="col">Measured (4.5.11 / 5.1.2 / 5.2.1)</th></tr></thead><tbody><tr><td>Base triangles</td><td>5160–5410</td><td>5284 / 5284 / 5284</td></tr><tr><td>LOD1 ratio</td><td>0.32–0.62 of base</td><td>0.5000 / 0.5000 / 0.5000</td></tr><tr><td>LOD2 ratio</td><td>0.10–0.35 of base</td><td>0.2199 / 0.2199 / 0.2146</td></tr><tr><td>Materials</td><td>exactly 2 distinct, metal ≥ 800, wood ≥ 1200 faces</td><td>2 slots; 1196 metal, 1694 wood</td></tr><tr><td>UVs</td><td>in <code>0..1</code>, AABB overlap ≤ 1e-5</td><td>in range, overlap 0</td></tr><tr><td>Outer AABB</td><td>(1.580, 0.842, 0.640) m ± 0.01</td><td>(1.5800, 0.8420, 0.6400)</td></tr><tr><td>Collider tris</td><td>≤ 360</td><td>192</td></tr><tr><td>Bake texels</td><td>smallest UV cell ≥ 12 px at the baked resolution</td><td>17.45 px at 1024 px</td></tr><tr><td>Export</td><td>written, size &gt; 0, removed after measuring</td><td>403176 / 403176 / 403160 bytes</td></tr></tbody></table></div>
+<h3>Hygiene, supports and joints</h3>
+<p>Recomputed from the generated mesh on all three binaries, identical on each.</p>
+<div class="table-wrap"><table><thead><tr><th scope="col">Axis</th><th scope="col">Declared</th><th scope="col">Measured</th></tr></thead><tbody><tr><td>Loose V/E, non-manifold, zero-area, doubles @1e-5, n-gons</td><td>all 0</td><td>all 0</td></tr><tr><td>Z-fighting</td><td>coplanar cross-shell face pairs = 0</td><td>0</td></tr><tr><td>Grounded</td><td>bbox min Z within 1e-4 of 0</td><td>0.0000</td></tr><tr><td>Named supports</td><td>2 legs found; each tyre and leg zmin within 1e-4 of the floor</td><td>2 legs; all four 0.000000</td></tr><tr><td>Material-island gap</td><td>metal↔wood min distance ≤ 0.008 m</td><td>0.00023</td></tr><tr><td>Wall boards</td><td>2 boards per side wall, seams 0.0015–0.005 m</td><td>(2, 2), seams 0.00300</td></tr><tr><td>Tyre seat</td><td>0.0030–0.0055 m interference, per angular station</td><td>[0.00400, 0.00400] over 48 stations</td></tr><tr><td>One assembly</td><td>the shells&#x27; BVH-overlap graph is 1 component</td><td>1 component, 59 shells</td></tr><tr><td>Wheel mirror</td><td>the two wheels match in X, Z and extent within 5e-5 m</td><td>0.00000 mm</td></tr><tr><td>Edge treatment</td><td>manifold edges within 5° of 90° = 0</td><td>0 wood, 0 iron</td></tr></tbody></table></div>
+<p>DECIMATE COLLAPSE triangle counts are <strong>not</strong> identical across series. 5.2.1 is more aggressive on LOD2, so 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> plus the texel floor, not byte-identity. Per-board tone comes from <code>random.Random(TONE_SEED)</code>, so it is identical run to run. Export byte counts differ by a few bytes across series (glTF serializer). The gate is &quot;written and non-empty&quot;, not a byte count, and the file is removed once measured.</p>
+<p>The bake cage is 0.01 m: it only has to cover the chamfer difference between the 3-segment high and the 1-segment low. At 0.08 m it reached past the 74 mm between a side wall and its wheel, so rays from the wall hit the high-poly felloe. The wheel&#x27;s rim baked onto the board as a black staircase.</p>
 <h2>Falsifiers</h2>
-<p>Each flag breaks one stage so a <strong>named</strong> budget fails and the piece exits <em>that</em> code. Magnitudes are sized so no earlier gate can steal the failure: the two wheel moves stay inside <code>BBOX_TOL</code>, so the AABB gate (exit 8) still passes.</p>
-<div class="table-wrap"><table><thead><tr><th scope="col">Flag</th><th scope="col">Target budget</th><th scope="col">Exit</th></tr></thead><tbody><tr><td><code>--skip-decimate</code></td><td>LOD1 ratio band (ratio becomes 1.0)</td><td>9</td></tr><tr><td><code>--lift-z</code></td><td>AABB grounded zmin (whole mesh up 0.05 m)</td><td>16</td></tr><tr><td><code>--flush-tyre</code></td><td>Coplanar cross-shell pairs — sets the tyre&#x27;s inner radius equal to the felloe&#x27;s outer radius, which is the construction bug this piece was rebuilt to remove (0 → 48 pairs)</td><td>15</td></tr><tr><td><code>--sink-tyre</code></td><td>Tyre seat band — buries the hoop 9 mm into the felloe so it reads as one body</td><td>18</td></tr><tr><td><code>--float-wheel</code></td><td>Named supports — lifts one wheel 3 mm while the other still grounds the AABB</td><td>16</td></tr><tr><td><code>--skew-wheel</code></td><td>Wheel mirror — pushes one wheel 6 mm out along the track</td><td>19</td></tr></tbody></table></div>
-<p><code>--lift-z</code> and <code>--float-wheel</code> share exit 16 and fail different budgets: <code>--lift-z</code> fails the AABB gate, which fires first; <code>--float-wheel</code> leaves the AABB grounded, so only the per-tyre support check can catch it.</p>
+<p>Each flag breaks one stage so a <strong>named</strong> budget fails and the piece exits <em>that</em> code. Magnitudes are sized so no earlier gate can steal the failure. The wheel, leg and bed moves stay inside <code>BBOX_TOL</code>, so the AABB gate (exit 8) still passes, and no flag changes the triangle count by more than the band allows.</p>
+<div class="table-wrap"><table><thead><tr><th scope="col">Flag</th><th scope="col">Target budget</th><th scope="col">Exit</th></tr></thead><tbody><tr><td><code>--skip-decimate</code></td><td>LOD1 ratio band (ratio becomes 1.0)</td><td>9</td></tr><tr><td><code>--flush-tyre</code></td><td>Coplanar cross-shell pairs: sets the tyre&#x27;s inner radius equal to the felloe&#x27;s outer radius, which is the construction bug this piece was rebuilt to remove (0 → 144 pairs)</td><td>15</td></tr><tr><td><code>--lift-z</code></td><td>AABB grounded zmin (whole mesh up 0.05 m)</td><td>16</td></tr><tr><td><code>--float-wheel</code></td><td>Named supports: lifts one wheel 3 mm while the other still grounds the AABB</td><td>16</td></tr><tr><td><code>--short-props</code></td><td>Named supports: stops both prop legs 3 mm above the floor while the tyres still ground the AABB</td><td>16</td></tr><tr><td><code>--wide-seams</code></td><td>Wall board seams: opens every seam to 10 mm, same triangle count</td><td>17</td></tr><tr><td><code>--sink-tyre</code></td><td>Tyre seat band: buries the hoop 9 mm into the felloe so it reads as one body</td><td>18</td></tr><tr><td><code>--lift-bed</code></td><td>One assembly: raises the box (planks, walls, straps) 7 mm off its rails, so the contact graph splits in two</td><td>18</td></tr><tr><td><code>--skew-wheel</code></td><td>Wheel mirror: pushes one wheel 6 mm out along the track</td><td>19</td></tr><tr><td><code>--sharp-bar</code></td><td>Edge treatment: leaves the pull bar&#x27;s rims unchamfered (24 right-angle edges, 48 triangles short)</td><td>20</td></tr><tr><td><code>--low-bake</code></td><td>Bake texel density: bakes at 256 px (4.36 px per cell)</td><td>21</td></tr></tbody></table></div>
+<p><code>--lift-z</code>, <code>--float-wheel</code> and <code>--short-props</code> share exit 16 and fail different budgets. <code>--lift-z</code> fails the AABB gate, which fires first. The other two leave the AABB grounded, so only the per-support check can catch them. <code>--sharp-bar</code> replaced a flag that skipped the whole iron chamfer pass. That flag dropped 1200 triangles and tripped the triangle floor (exit 4) instead of the edge budget.</p>
 <h2>Run</h2>
 <pre><code>blender --background --python cart.py --
 blender --background --python cart.py -- --skip-decimate
-blender --background --python cart.py -- --lift-z
 blender --background --python cart.py -- --flush-tyre
-blender --background --python cart.py -- --sink-tyre
+blender --background --python cart.py -- --lift-z
 blender --background --python cart.py -- --float-wheel
+blender --background --python cart.py -- --short-props
+blender --background --python cart.py -- --wide-seams
+blender --background --python cart.py -- --sink-tyre
+blender --background --python cart.py -- --lift-bed
 blender --background --python cart.py -- --skew-wheel
+blender --background --python cart.py -- --sharp-bar
+blender --background --python cart.py -- --low-bake
 blender --background --python cart.py -- --output cart.png</code></pre>
 <p>Smoke passes none of the falsifier flags and no <code>--output</code>.</p>
 <h2>Exit codes</h2>
 <p>File-local. <code>9</code> is a valid check code. <code>10</code> is reserved for <code>gallery_framing.check_framing</code> on the <code>--output</code> path.</p>
-<div class="table-wrap"><table><thead><tr><th scope="col">Code</th><th scope="col">Meaning</th></tr></thead><tbody><tr><td>0</td><td>Success</td></tr><tr><td>1</td><td>Uncaught exception (FATAL wrapper)</td></tr><tr><td>2</td><td>argparse / usage</td></tr><tr><td>3</td><td>Mesh did not build / no UV layer</td></tr><tr><td>4</td><td>Base triangle count outside range</td></tr><tr><td>5</td><td>Material count ≠ 2 distinct slots, or metal faces missing</td></tr><tr><td>6</td><td>UVs outside 0..1</td></tr><tr><td>7</td><td>UV AABB overlap above tolerance</td></tr><tr><td>8</td><td>World AABB off declared outer size</td></tr><tr><td>9</td><td>LOD ratio band (<code>--skip-decimate</code> lands here)</td></tr><tr><td>10</td><td>Framing gate (render path only)</td></tr><tr><td>11</td><td>Collider triangle count above ceiling</td></tr><tr><td>12</td><td>Bake did not finish or image has no data</td></tr><tr><td>13</td><td>Export file missing or empty</td></tr><tr><td>14</td><td><code>--output</code> produced no file</td></tr><tr><td>15</td><td>Hygiene: loose geometry, non-manifold, zero-area, doubles, n-gons, or coplanar cross-shell face pairs (<code>--flush-tyre</code> lands here)</td></tr><tr><td>16</td><td>Bbox min Z not grounded (<code>--lift-z</code>), or a named support off the floor (<code>--float-wheel</code>)</td></tr><tr><td>17</td><td>Material-island gap above tolerance (parts meant to touch)</td></tr><tr><td>18</td><td>Tyre seat depth outside its band (<code>--sink-tyre</code> lands here)</td></tr><tr><td>19</td><td>Wheel mirror deviation above epsilon (<code>--skew-wheel</code> lands here)</td></tr></tbody></table></div>
+<div class="table-wrap"><table><thead><tr><th scope="col">Code</th><th scope="col">Meaning</th></tr></thead><tbody><tr><td>0</td><td>Success</td></tr><tr><td>1</td><td>Uncaught exception (FATAL wrapper)</td></tr><tr><td>2</td><td>argparse / usage</td></tr><tr><td>3</td><td>Mesh did not build / no UV layer / wheels not found</td></tr><tr><td>4</td><td>Base triangle count outside range</td></tr><tr><td>5</td><td>Material count ≠ 2 distinct slots, or a face-count floor missed</td></tr><tr><td>6</td><td>UVs outside 0..1</td></tr><tr><td>7</td><td>UV AABB overlap above tolerance</td></tr><tr><td>8</td><td>World AABB off declared outer size</td></tr><tr><td>9</td><td>LOD ratio band (<code>--skip-decimate</code> lands here)</td></tr><tr><td>10</td><td>Framing gate (render path only)</td></tr><tr><td>11</td><td>Collider triangle count above ceiling</td></tr><tr><td>12</td><td>Bake did not finish or image has no data</td></tr><tr><td>13</td><td>Export file missing or empty</td></tr><tr><td>14</td><td><code>--output</code> produced no file</td></tr><tr><td>15</td><td>Hygiene: loose geometry, non-manifold, zero-area, doubles, n-gons, or coplanar cross-shell face pairs (<code>--flush-tyre</code> lands here)</td></tr><tr><td>16</td><td>Bbox min Z not grounded (<code>--lift-z</code>), or a named support off the floor (<code>--float-wheel</code>, <code>--short-props</code>)</td></tr><tr><td>17</td><td>Material-island gap above tolerance, or wall boards miscounted or their seams out of band (<code>--wide-seams</code>)</td></tr><tr><td>18</td><td>Tyre seat depth outside its band (<code>--sink-tyre</code>), or the shells not one connected assembly (<code>--lift-bed</code>)</td></tr><tr><td>19</td><td>Wheel mirror deviation above epsilon (<code>--skew-wheel</code> lands here)</td></tr><tr><td>20</td><td>A right-angle edge survived the chamfer passes (<code>--sharp-bar</code> lands here)</td></tr><tr><td>21</td><td>Bake texel density below the floor (<code>--low-bake</code> lands here)</td></tr></tbody></table></div>
     </section>
     <section class="detail-section src">
       <h2>Source</h2>
@@ -309,26 +319,32 @@ <h2>Source</h2>
         <code>showcase/cart/cart.py</code>
         <a href="https://github.com/TMHSDigital/Blender-Developer-Tools/tree/main/showcase/cart/cart.py">View on GitHub &rarr;</a>
       </div>
-      <pre><span class="s">&quot;&quot;&quot;Game-ready two-wheel wooden cart — a showcase piece, not an example.
+      <pre><span class="s">&quot;&quot;&quot;Game-ready two-wheel handcart — a showcase piece, not an example.
 
-Asserts budget conformance of a procedural cart (staved bed, side
-walls, shafts, spoked wheels, iron hubs and axle) 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 handcart (planked bed on two
+rails that run on as shafts, board walls with iron corner straps, prop
+legs, spoked wheels on long naves, iron tyres, axle and washers) after
+composing shipped pipeline pieces: bmesh construction, UVs, two
+materials, high-to-low normal bake, LOD chain, convex collider, Unity
+glTF export.
 
 Budgets are declared below and recomputed from the generated result.
 They are not API-contract witnesses. Each falsifier flag breaks one
 stage so a named budget fails and the piece exits that budget&#x27;s code:
-``--skip-decimate`` (LOD ratio, 9), ``--lift-z`` (AABB grounded, 16),
-``--float-wheel`` (named supports, 16), ``--flush-tyre`` (coplanar
-cross-shell pairs, 15), ``--sink-tyre`` (tyre seat band, 18),
-``--skew-wheel`` (wheel mirror, 19). The two wheel moves stay inside
-``BBOX_TOL`` so the AABB gate cannot steal the failure.
-
-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.
+``--skip-decimate`` (LOD ratio, 9), ``--flush-tyre`` (coplanar
+cross-shell pairs, 15), ``--lift-z`` (AABB grounded, 16),
+``--float-wheel`` and ``--short-props`` (named supports, 16),
+``--wide-seams`` (wall board seams, 17), ``--sink-tyre`` (tyre seat
+band, 18), ``--lift-bed`` (one connected assembly, 18), ``--skew-wheel``
+(wheel mirror, 19), ``--sharp-bar`` (edge treatment, 20), ``--low-bake``
+(bake texel density, 21). The wheel,
+leg and bed moves stay inside ``BBOX_TOL`` so the AABB gate cannot steal
+the failure.
+
+Seeded, not random: per-board tone uses ``random.Random(TONE_SEED)``.
+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.
 
     blender --background --python cart.py --
     blender --background --python cart.py -- --skip-decimate
@@ -338,6 +354,7 @@ <h2>Source</h2>
 <span class="k">import</span> argparse
 <span class="k">import</span> math
 <span class="k">import</span> os
+<span class="k">import</span> random
 <span class="k">import</span> sys
 <span class="k">import</span> tempfile
 <span class="k">import</span> traceback
@@ -346,6 +363,7 @@ <h2>Source</h2>
 <span class="k">import</span> bpy
 <span class="k">from</span> mathutils <span class="k">import</span> Euler, Vector
 <span class="k">from</span> mathutils.bvhtree <span class="k">import</span> BVHTree
+<span class="k">from</span> mathutils.kdtree <span class="k">import</span> KDTree
 
 _REPO = os.path.abspath(
     os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir, os.pardir)
@@ -354,10 +372,12 @@ <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>
 
-RIM_MAJOR = <span class="n">0.30</span>
-<span class="c"># Felloe ring: flat-tread box section, not a round tube — round torus rims</span>
-<span class="c"># read as bicycle wheels. The iron tyre wraps the tread.</span>
-RIM_RADIAL = <span class="n">0.012</span>
+RIM_OUTER = <span class="n">0.312</span>
+<span class="c"># Felloe: flat-tread box section, not a round tube — round torus rims read</span>
+<span class="c"># as bicycle wheels. RIM_RADIAL is the half-depth: a 40 mm felloe. The</span>
+<span class="c"># first build&#x27;s 24 mm read as a bent strip at hero size.</span>
+RIM_RADIAL = <span class="n">0.020</span>
+RIM_MAJOR = RIM_OUTER - RIM_RADIAL
 RIM_W = <span class="n">0.036</span>
 TYRE_T = <span class="n">0.008</span>
 TYRE_W = <span class="n">0.040</span>
@@ -366,38 +386,109 @@ <h2>Source</h2>
 <span class="c"># set equal to it: r_in == r_out puts the tyre&#x27;s inner cylinder and the</span>
 <span class="c"># felloe&#x27;s tread on one plane for every segment, which is a guaranteed</span>
 <span class="c"># z-fight (it measured 32 coplanar cross-shell pairs, 16 per wheel).</span>
-RIM_OUTER = RIM_MAJOR + RIM_RADIAL
 TYRE_SEAT = <span class="n">0.004</span>
 TYRE_SEAT_MIN = <span class="n">0.0030</span>
 TYRE_SEAT_MAX = <span class="n">0.0055</span>
+WHEEL_R = RIM_OUTER + TYRE_T
 WHEEL_SEGMENTS = <span class="n">24</span>
 TRACK = <span class="n">0.68</span>
-AXLE_X = -<span class="n">0.16</span>
 AXLE_R = <span class="n">0.020</span>
-HUB_R = <span class="n">0.052</span>
-HUB_W = <span class="n">0.046</span>
-N_SPOKES = <span class="n">8</span>
-SPOKE_T = <span class="n">0.018</span>
+<span class="c"># The axle runs past each washer, so a washer pushed out by --skew-wheel</span>
+<span class="c"># still stops short of the axle&#x27;s end cap instead of landing on its plane.</span>
+AXLE_PROUD = <span class="n">0.016</span>
+<span class="c"># A nave is a long barrel, not a disc. The first build&#x27;s 46 mm hub read as</span>
+<span class="c"># a toy wheel in every view; 130 mm with an iron band at each end is a</span>
+<span class="c"># cartwheel&#x27;s proportion.</span>
+NAVE_L = <span class="n">0.130</span>
+NAVE_R_END = <span class="n">0.044</span>
+NAVE_R_MID = <span class="n">0.058</span>
+NAVE_BAND_ZONE = <span class="n">0.028</span>
+NAVE_BAND_W = <span class="n">0.016</span>
+NAVE_BAND_T = <span class="n">0.006</span>
+NAVE_BAND_BITE = <span class="n">0.002</span>
+NAVE_SEGS = <span class="n">12</span>
+WASHER_R = <span class="n">0.032</span>
+WASHER_BITE = <span class="n">0.003</span>
+WASHER_T = <span class="n">0.009</span>
+N_SPOKES = <span class="n">10</span>
+SPOKE_W = <span class="n">0.022</span>
+SPOKE_D = <span class="n">0.018</span>
+SPOKE_ROOT = <span class="n">0.020</span>
+SPOKE_TENON = <span class="n">0.014</span>
+
+<span class="c"># Chassis, stacked from the axle up. Each member bites the one below it by</span>
+<span class="c"># a named depth, so nothing rests on a tangent line or floats.</span>
 BED_L = <span class="n">0.92</span>
 BED_W = <span class="n">0.50</span>
-BED_T = <span class="n">0.038</span>
-WALL_H = <span class="n">0.16</span>
-WALL_T = <span class="n">0.032</span>
-TAILGATE_H = <span class="n">0.10</span>
-SHAFT_L = <span class="n">0.58</span>
-SHAFT_T = <span class="n">0.034</span>
-SHAFT_PITCH = math.radians(<span class="n">7.0</span>)
-N_SLATS = <span class="n">6</span>
-IRON_T = <span class="n">0.014</span>
+BED_CX = <span class="n">0.06</span>
+AXLE_X = BED_CX - <span class="n">0.22</span>
+AXLE_BITE = <span class="n">0.006</span>
 BOLSTER_H = <span class="n">0.044</span>
+BOLSTER_X = <span class="n">0.060</span>
+BOLSTER_SPAN = <span class="n">0.52</span>
+RAIL_Y = <span class="n">0.17</span>
+RAIL_W = <span class="n">0.040</span>
+RAIL_H = <span class="n">0.050</span>
+RAIL_BITE = <span class="n">0.006</span>
+RAIL_BACK = <span class="n">0.03</span>
+FLOOR_T = <span class="n">0.030</span>
+N_FLOOR = <span class="n">9</span>
+FLOOR_GAP = <span class="n">0.004</span>
+FLOOR_BITE = <span class="n">0.004</span>
+<span class="c"># Walls stand on the floor, inset from its edge. The first build hung them</span>
+<span class="c"># outside the planks at mid-thickness, which left every slat end poking out</span>
+<span class="c"># under the front board as a row of teeth; flush with the plank ends they</span>
+<span class="c"># would share the end grain&#x27;s plane.</span>
+WALL_H = <span class="n">0.18</span>
+WALL_T = <span class="n">0.028</span>
+WALL_SEAT = <span class="n">0.006</span>
+WALL_INSET = <span class="n">0.004</span>
+WALL_BOARDS = <span class="n">2</span>
+WALL_SEAM = <span class="n">0.003</span>
+WALL_SEAM_MIN = <span class="n">0.0015</span>
+WALL_SEAM_MAX = <span class="n">0.005</span>
+WIDE_SEAM = <span class="n">0.010</span>
+<span class="c"># End boards sit between the side walls: recessed, seated deeper, split at</span>
+<span class="c"># a different height and topped lower, so no face of an end board lands on</span>
+<span class="c"># a plane of a side board.</span>
+END_INSET = <span class="n">0.003</span>
+END_BITE = <span class="n">0.012</span>
+END_SEAT = <span class="n">0.009</span>
+END_SPLIT = <span class="n">0.46</span>
+END_DROP = <span class="n">0.008</span>
+TAILGATE_H = <span class="n">0.100</span>
+SHAFT_L = <span class="n">0.58</span>
+HANDLE_R = <span class="n">0.017</span>
+HANDLE_BACK = <span class="n">0.07</span>
+HANDLE_PROUD = <span class="n">0.012</span>
+<span class="c"># The first build hovered its shaft tips 0.30 m off the floor with the</span>
+<span class="c"># centre of mass ahead of the axle: it would tip. Two prop legs under the</span>
+<span class="c"># rails stand it level. Thinner than the rail, so their faces never share</span>
+<span class="c"># its planes.</span>
+LEG_T = <span class="n">0.034</span>
+LEG_BACK = <span class="n">0.09</span>
+LEG_BITE = <span class="n">0.024</span>
+SHORT_PROP_Z = <span class="n">0.003</span>
+<span class="c"># Iron corner straps: one L-section shell per corner, bitten into both</span>
+<span class="c"># faces of the side wall it is nailed to.</span>
+STRAP_LEG = <span class="n">0.050</span>
+STRAP_T = <span class="n">0.004</span>
+STRAP_BITE = <span class="n">0.0015</span>
+STRAP_MARGIN = <span class="n">0.012</span>
+IRON_BEVEL = <span class="n">0.0012</span>
+BEVEL_MIN_ANGLE = math.radians(<span class="n">50.0</span>)
+PLANK_TONE_JITTER = <span class="n">0.28</span>
+TONE_SEED = <span class="n">31</span>
+WOOD_GRAIN_SCALE = <span class="n">30.0</span>
 
 BBOX_TOL = <span class="n">0.01</span>
-OUTER_SIZE = (<span class="n">1.539</span>, <span class="n">0.749</span>, <span class="n">0.640</span>)
-<span class="c"># Re-fitted after the wheel went from 16 to 24 segments (2600 -&gt; 2856).</span>
-<span class="c"># Narrower than the band it replaces (200 wide, was 430) and centred on</span>
-<span class="c"># the measured value, so this is a tightening, not a widening.</span>
-BASE_TRIS_MIN = <span class="n">2760</span>
-BASE_TRIS_MAX = <span class="n">2960</span>
+<span class="c"># Rails run on as shafts past the bed (X); axle ends past the washers (Y);</span>
+<span class="c"># the tyre tops (Z). Re-declared for the rebuild: 1.539 x 0.749 before.</span>
+OUTER_SIZE = (<span class="n">1.580</span>, <span class="n">0.842</span>, <span class="n">0.640</span>)
+<span class="c"># Re-fitted for the rebuild (2856 -&gt; 5284: naves, bands, washers, straps,</span>
+<span class="c"># legs, boards). Centred on the measurement, 250 wide against the old 200.</span>
+BASE_TRIS_MIN = <span class="n">5160</span>
+BASE_TRIS_MAX = <span class="n">5410</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>
@@ -413,10 +504,20 @@ <h2>Source</h2>
 UV_EPS = <span class="n">1e-4</span>
 UV_OVERLAP_MAX = <span class="n">1e-5</span>
 COLLIDER_TRIS_MAX = <span class="n">360</span>
-BAKE_RES = <span class="n">256</span>
-CAGE_EXTRUSION = <span class="n">0.08</span>
-METAL_FACES_MIN = <span class="n">24</span>
-WOOD_FACES_MIN = <span class="n">800</span>
+<span class="c"># One UV cell per face: at 256 px each of the ~2900 faces got about 4 px,</span>
+<span class="c"># and the render&#x27;s bilinear lookup read neighbouring cells&#x27; normals as a</span>
+<span class="c"># black hexagon and sandpaper speckle on the side boards (tavern-stool&#x27;s</span>
+<span class="c"># defect). 1024 px gives every cell 17 px against a 12 px floor.</span>
+BAKE_RES = <span class="n">1024</span>
+LOW_BAKE_RES = <span class="n">256</span>
+TEXEL_MIN = <span class="n">12.0</span>
+<span class="c"># The cage only has to cover the chamfer difference between the 3-segment</span>
+<span class="c"># high and the 1-segment low (under 2 mm). At 0.08 it reached past the</span>
+<span class="c"># 74 mm between side wall and felloe, so rays from the wall hit the high</span>
+<span class="c"># wheel and baked its rim onto the board as a black staircase.</span>
+CAGE_EXTRUSION = <span class="n">0.01</span>
+METAL_FACES_MIN = <span class="n">800</span>
+WOOD_FACES_MIN = <span class="n">1200</span>
 
 <span class="c"># Z-fighting: two separate bodies landing on one plane. Cross-shell, with</span>
 <span class="c"># hay-bale&#x27;s constants (copied, not imported).</span>
@@ -424,11 +525,21 @@ <h2>Source</h2>
 COPLANAR_PLANE_EPS = <span class="n">1e-4</span>
 COPLANAR_CENTRE_MAX = <span class="n">0.05</span>
 ZFIGHT_PAIRS_MAX = <span class="n">0</span>
-<span class="c"># Named supports: a two-wheel cart&#x27;s AABB zmin is grounded by whichever</span>
-<span class="c"># tyre happens to be lowest. Each tyre carries its own floor contact.</span>
+<span class="c"># Named supports: two tyres and two prop legs. The AABB zmin is grounded by</span>
+<span class="c"># whichever of them is lowest, so each carries its own floor contact.</span>
 SUPPORT_ZMIN_EPS = <span class="n">1e-4</span>
+N_LEGS = <span class="n">2</span>
 <span class="c"># Mirrored members: the two wheels are the same part reflected in Y.</span>
 WHEEL_MIRROR_EPS = <span class="n">5e-5</span>
+<span class="c"># Every member is joined to the rest: the BVH-overlap graph of the shells</span>
+<span class="c"># is one component. A bed resting a hair above its rails passes every</span>
+<span class="c"># per-part budget and is still a floating box.</span>
+CONTACT_COMPONENTS = <span class="n">1</span>
+LIFT_BED = FLOOR_BITE + <span class="n">0.003</span>
+<span class="c"># Edge treatment: every edge is chamfered, so a manifold edge still within</span>
+<span class="c"># RIGHT_ANGLE_TOL of 90 degrees is one a bevel pass skipped.</span>
+RIGHT_ANGLE_TOL = math.radians(<span class="n">5.0</span>)
+RIGHT_ANGLE_MAX = <span class="n">0</span>
 <span class="c"># Falsifier magnitudes, each sized to trip its own budget and nothing</span>
 <span class="c"># earlier: the wheel moves stay inside BBOX_TOL so the AABB gate cannot</span>
 <span class="c"># steal the failure.</span>
@@ -472,6 +583,12 @@ <h2>Source</h2>
         ob.select_set(<span class="k">False</span>)
 
 
+<span class="k">def</span> _faces_of(verts, mat_idx):
+    faces = {f <span class="k">for</span> v <span class="k">in</span> verts <span class="k">for</span> f <span class="k">in</span> v.link_faces}
+    <span class="k">for</span> f <span class="k">in</span> faces:
+        f.material_index = mat_idx
+
+
 <span class="k">def</span> add_box(bm, loc, scale, mat_idx, euler=(<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>)):
     geo = bmesh.ops.create_cube(bm, size=<span class="n">1.0</span>)
     verts = geo[<span class="s">&quot;verts&quot;</span>]
@@ -480,12 +597,37 @@ <h2>Source</h2>
     <span class="k">for</span> v <span class="k">in</span> verts:
         p = Vector((v.co.x * scale[<span class="n">0</span>], v.co.y * scale[<span class="n">1</span>], v.co.z * scale[<span class="n">2</span>]))
         v.co = rot @ p + origin
-    faces = {f <span class="k">for</span> v <span class="k">in</span> verts <span class="k">for</span> f <span class="k">in</span> v.link_faces}
-    <span class="k">for</span> f <span class="k">in</span> faces:
-        f.material_index = mat_idx
+    _faces_of(verts, mat_idx)
     <span class="k">return</span> verts
 
 
+<span class="k">def</span> add_span(bm, lo, hi, mat_idx):
+    <span class="s">&quot;&quot;&quot;Axis-aligned box from its min corner to its max corner.&quot;&quot;&quot;</span>
+    lo = Vector(lo)
+    hi = Vector(hi)
+    <span class="k">return</span> add_box(bm, (lo + hi) * <span class="n">0.5</span>, hi - lo, mat_idx)
+
+
+<span class="k">def</span> add_oriented_box(bm, a, b, scale_xy, mat_idx):
+    <span class="s">&quot;&quot;&quot;Box whose long axis runs from station ``a`` to station ``b``.
+
+    For a direction in the XZ plane the rotation is about Y alone, so the
+    box&#x27;s local Y stays world Y — a spoke&#x27;s thin side stays along the axle.
+    &quot;&quot;&quot;</span>
+    a = Vector(a)
+    b = Vector(b)
+    delta = b - a
+    length = delta.length
+    <span class="k">if</span> length &lt; <span class="n">1e-8</span>:
+        <span class="k">return</span> []
+    quat = Vector((<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">1.0</span>)).rotation_difference(delta.normalized())
+    eul = quat.to_euler(<span class="s">&quot;XYZ&quot;</span>)
+    <span class="k">return</span> add_box(
+        bm, (a + b) * <span class="n">0.5</span>, (scale_xy[<span class="n">0</span>], scale_xy[<span class="n">1</span>], length), mat_idx,
+        euler=(eul.x, eul.y, eul.z),
+    )
+
+
 <span class="k">def</span> add_cyl(bm, loc, radius, depth, segments, mat_idx, euler=(<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>)):
     geo = bmesh.ops.create_cone(
         bm,
@@ -501,21 +643,19 @@ <h2>Source</h2>
     origin = Vector(loc)
     <span class="k">for</span> v <span class="k">in</span> verts:
         v.co = rot @ v.co + origin
-    faces = {f <span class="k">for</span> v <span class="k">in</span> verts <span class="k">for</span> f <span class="k">in</span> v.link_faces}
-    <span class="k">for</span> f <span class="k">in</span> faces:
-        f.material_index = mat_idx
+    _faces_of(verts, mat_idx)
     <span class="k">return</span> verts
 
 
-<span class="k">def</span> add_ring(bm, loc, r_mid, radial_t, width, segments, mat_idx, euler=(<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>)):
-    <span class="s">&quot;&quot;&quot;Flat-sided ring with a box cross-section (felloe / tyre profile).
+<span class="k">def</span> add_ring(bm, loc, r_in, r_out, width, segments, mat_idx):
+    <span class="s">&quot;&quot;&quot;Flat-sided ring with a box cross-section, its axis along world Y.
 
     Manifold: outer tread, inner surface, and two side annuli, all quads.
-    Built in the XY plane, width along Z, then rotated/translated.
+    Built in the XZ plane with u measured from +X toward +Z, so a segment
+    count divisible by four puts a vertex at the very bottom.
     &quot;&quot;&quot;</span>
-    r_in = r_mid - radial_t
-    r_out = r_mid + radial_t
     hw = width / <span class="n">2.0</span>
+    ox, oy, oz = loc
     rings = []
     <span class="k">for</span> i <span class="k">in</span> range(segments):
         u = i * (<span class="n">2.0</span> * math.pi / segments)
@@ -523,30 +663,95 @@ <h2>Source</h2>
         su = math.sin(u)
         rings.append(
             [
-                bm.verts.new((r_in * cu, r_in * su, -hw)),
-                bm.verts.new((r_out * cu, r_out * su, -hw)),
-                bm.verts.new((r_out * cu, r_out * su, hw)),
-                bm.verts.new((r_in * cu, r_in * su, hw)),
+                bm.verts.new((ox + r_in * cu, oy - hw, oz + r_in * su)),
+                bm.verts.new((ox + r_out * cu, oy - hw, oz + r_out * su)),
+                bm.verts.new((ox + r_out * cu, oy + hw, oz + r_out * su)),
+                bm.verts.new((ox + r_in * cu, oy + hw, oz + r_in * su)),
             ]
         )
     <span class="k">for</span> i <span class="k">in</span> range(segments):
-        i2 = (i + <span class="n">1</span>) % segments
         a = rings[i]
-        b = rings[i2]
+        b = rings[(i + <span class="n">1</span>) % segments]
         <span class="k">for</span> quad <span class="k">in</span> (
             (a[<span class="n">1</span>], b[<span class="n">1</span>], b[<span class="n">2</span>], a[<span class="n">2</span>]),
             (a[<span class="n">3</span>], b[<span class="n">3</span>], b[<span class="n">0</span>], a[<span class="n">0</span>]),
             (a[<span class="n">2</span>], b[<span class="n">2</span>], b[<span class="n">3</span>], a[<span class="n">3</span>]),
             (a[<span class="n">0</span>], b[<span class="n">0</span>], b[<span class="n">1</span>], a[<span class="n">1</span>]),
         ):
-            face = bm.faces.new(quad)
-            face.material_index = mat_idx
-    verts = [v <span class="k">for</span> ring <span class="k">in</span> rings <span class="k">for</span> v <span class="k">in</span> ring]
-    rot = Euler(euler).to_matrix()
-    origin = Vector(loc)
-    <span class="k">for</span> v <span class="k">in</span> verts:
-        v.co = rot @ v.co + origin
-    <span class="k">return</span> verts
+            bm.faces.new(quad).material_index = mat_idx
+    <span class="k">return</span> [v <span class="k">for</span> ring <span class="k">in</span> rings <span class="k">for</span> v <span class="k">in</span> ring]
+
+
+<span class="k">def</span> add_lathe_y(bm, loc, profile, segments, mat_idx):
+    <span class="s">&quot;&quot;&quot;Closed solid of revolution about world Y from ``(dy, radius)`` pairs.
+
+    Capped at both ends with an n-gon that ``finish_caps`` triangulates
+    after the chamfer pass: a triangle-fan cap, chamfered 5 mm at its rim,
+    folded its centre out through the cap as non-manifold slivers.
+    &quot;&quot;&quot;</span>
+    ox, oy, oz = loc
+    rings = []
+    <span class="k">for</span> dy, r <span class="k">in</span> profile:
+        ring = []
+        <span class="k">for</span> i <span class="k">in</span> range(segments):
+            u = <span class="n">2.0</span> * math.pi * i / segments
+            ring.append(bm.verts.new(
+                (ox + r * math.cos(u), oy + dy, oz + r * math.sin(u))))
+        rings.append(ring)
+    <span class="k">for</span> a, b <span class="k">in</span> zip(rings, rings[<span class="n">1</span>:]):
+        <span class="k">for</span> k <span class="k">in</span> range(segments):
+            kn = (k + <span class="n">1</span>) % segments
+            bm.faces.new((a[k], a[kn], b[kn], b[k])).material_index = mat_idx
+    bm.faces.new(list(reversed(rings[<span class="n">0</span>]))).material_index = mat_idx
+    bm.faces.new(rings[-<span class="n">1</span>]).material_index = mat_idx
+    <span class="k">return</span> [v <span class="k">for</span> ring <span class="k">in</span> rings <span class="k">for</span> v <span class="k">in</span> ring]
+
+
+<span class="k">def</span> add_l_strap(bm, corner, sx, sy, z0, z1, mat_idx):
+    <span class="s">&quot;&quot;&quot;One L-section iron strap wrapped round a vertical box corner.
+
+    ``corner`` is the wood&#x27;s outer corner in plan; ``sx``/``sy`` point out
+    of the box. Both legs bite ``STRAP_BITE`` into the wood faces. One
+    shell: two overlapping boxes would chamfer a strip onto the same line
+    twice. Each cap is one L n-gon until ``finish_caps`` triangulates it
+    after the chamfer pass; caps pre-split on the inner-corner diagonal
+    left 24 non-manifold edges per strap once the reflex corner was
+    chamfered.
+    &quot;&quot;&quot;</span>
+    xc, yc = corner
+    b, t, leg = STRAP_BITE, STRAP_T, STRAP_LEG
+    xi, yi = xc - sx * b, yc - sy * b
+    xo, yo = xc + sx * (t - b), yc + sy * (t - b)
+    plan = [
+        (xi, yi),
+        (xi - sx * leg, yi),
+        (xi - sx * leg, yo),
+        (xo, yo),
+        (xo, yi - sy * leg),
+        (xi, yi - sy * leg),
+    ]
+    lo = [bm.verts.new((x, y, z0)) <span class="k">for</span> x, y <span class="k">in</span> plan]
+    hi = [bm.verts.new((x, y, z1)) <span class="k">for</span> x, y <span class="k">in</span> plan]
+    n = len(plan)
+    <span class="k">for</span> k <span class="k">in</span> range(n):
+        kn = (k + <span class="n">1</span>) % n
+        bm.faces.new((lo[k], lo[kn], hi[kn], hi[k])).material_index = mat_idx
+    bm.faces.new(list(reversed(lo))).material_index = mat_idx
+    bm.faces.new(hi).material_index = mat_idx
+    <span class="k">return</span> lo + hi
+
+
+<span class="k">def</span> finish_caps(bm):
+    <span class="s">&quot;&quot;&quot;Triangulate every face with more than four corners.
+
+    Lathe and strap caps are built as n-gons so the chamfer pass has clean
+    rims to work on; the shipped mesh carries no n-gon.
+    &quot;&quot;&quot;</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, quad_method=<span class="s">&quot;BEAUTY&quot;</span>, ngon_method=<span class="s">&quot;BEAUTY&quot;</span>,
+        )
 
 
 <span class="k">def</span> pack_uvs(bm, margin=<span class="n">0.08</span>):
@@ -592,216 +797,207 @@ <h2>Source</h2>
             )
 
 
+<span class="k">def</span> chassis_levels():
+    <span class="s">&quot;&quot;&quot;Z of every chassis level, stacked from the axle up by named bites.&quot;&quot;&quot;</span>
+    axle_z = WHEEL_R
+    bolster_z0 = axle_z + AXLE_R - AXLE_BITE
+    bolster_z1 = bolster_z0 + BOLSTER_H
+    rail_z0 = bolster_z1 - RAIL_BITE
+    rail_z1 = rail_z0 + RAIL_H
+    floor_z0 = rail_z1 - FLOOR_BITE
+    floor_z1 = floor_z0 + FLOOR_T
+    wall_z0 = floor_z1 - WALL_SEAT
+    <span class="k">return</span> {
+        <span class="s">&quot;axle&quot;</span>: axle_z, <span class="s">&quot;bolster0&quot;</span>: bolster_z0, <span class="s">&quot;bolster1&quot;</span>: bolster_z1,
+        <span class="s">&quot;rail0&quot;</span>: rail_z0, <span class="s">&quot;rail1&quot;</span>: rail_z1, <span class="s">&quot;floor0&quot;</span>: floor_z0,
+        <span class="s">&quot;floor1&quot;</span>: floor_z1, <span class="s">&quot;wall0&quot;</span>: wall_z0, <span class="s">&quot;wall1&quot;</span>: wall_z0 + WALL_H,
+    }
+
+
+<span class="k">def</span> board_heights(z0, total, n, seam, split=<span class="k">None</span>):
+    <span class="s">&quot;&quot;&quot;(bottom, top) of ``n`` boards stacked in ``total`` with ``seam`` gaps.&quot;&quot;&quot;</span>
+    <span class="k">if</span> n == <span class="n">1</span>:
+        <span class="k">return</span> [(z0, z0 + total)]
+    usable = total - (n - <span class="n">1</span>) * seam
+    <span class="k">if</span> split <span class="k">is</span> <span class="k">not</span> <span class="k">None</span> <span class="k">and</span> n == <span class="n">2</span>:
+        hs = [usable * split, usable * (<span class="n">1.0</span> - split)]
+    <span class="k">else</span>:
+        hs = [usable / n] * n
+    out = []
+    z = z0
+    <span class="k">for</span> h <span class="k">in</span> hs:
+        out.append((z, z + h))
+        z += h + seam
+    <span class="k">return</span> out
+
+
 <span class="k">def</span> add_wheel(bm, loc, wood, metal):
-    wood.extend(
-        add_ring(
-            bm, loc, RIM_MAJOR, RIM_RADIAL, RIM_W, WHEEL_SEGMENTS, WOOD_IDX,
-            euler=(math.pi / <span class="n">2.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>),
-        )
-    )
+    ox, oy, oz = loc
+    wood.extend(add_ring(
+        bm, loc, RIM_MAJOR - RIM_RADIAL, RIM_OUTER, RIM_W, WHEEL_SEGMENTS, WOOD_IDX,
+    ))
     <span class="c"># Hooped, not pasted on: inner radius is RIM_OUTER - TYRE_SEAT so the</span>
-    <span class="c"># band bites into the felloe, and the tread still lands at</span>
-    <span class="c"># RIM_OUTER + TYRE_T so the tyre stays the ground contact.</span>
-    tyre_in = RIM_OUTER - TYRE_SEAT
-    tyre_out = RIM_OUTER + TYRE_T
-    metal.extend(
-        add_ring(
-            bm, loc, <span class="n">0.5</span> * (tyre_in + tyre_out), <span class="n">0.5</span> * (tyre_out - tyre_in),
-            TYRE_W, WHEEL_SEGMENTS, METAL_IDX,
-            euler=(math.pi / <span class="n">2.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>),
-        )
-    )
-    wood.extend(
-        add_cyl(
-            bm,
-            loc,
-            HUB_R,
-            HUB_W,
-            <span class="n">12</span>,
-            WOOD_IDX,
-            euler=(math.pi / <span class="n">2.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>),
-        )
-    )
-    <span class="c"># Spokes root inside the hub and embed into the felloe ring — no</span>
-    <span class="c"># floating ends hidden by the hub band.</span>
-    inner = HUB_R * <span class="n">0.4</span>
-    outer = RIM_MAJOR - RIM_RADIAL + <span class="n">0.008</span>
-    mid_r = <span class="n">0.5</span> * (inner + outer)
-    slen = outer - inner
+    <span class="c"># band bites into the felloe, and the tread still lands at WHEEL_R so</span>
+    <span class="c"># the tyre stays the ground contact.</span>
+    metal.extend(add_ring(
+        bm, loc, RIM_OUTER - TYRE_SEAT, WHEEL_R, TYRE_W, WHEEL_SEGMENTS, METAL_IDX,
+    ))
+    zone = NAVE_BAND_ZONE
+    half = NAVE_L / <span class="n">2.0</span>
+    wood.extend(add_lathe_y(
+        bm, loc,
+        [(-half, NAVE_R_END), (-half + zone, NAVE_R_END), (<span class="n">0.0</span>, NAVE_R_MID),
+         (half - zone, NAVE_R_END), (half, NAVE_R_END)],
+        NAVE_SEGS, WOOD_IDX,
+    ))
+    <span class="k">for</span> s <span class="k">in</span> (-<span class="n">1.0</span>, <span class="n">1.0</span>):
+        metal.extend(add_ring(
+            bm, (ox, oy + s * (half - zone / <span class="n">2.0</span>), oz),
+            NAVE_R_END - NAVE_BAND_BITE, NAVE_R_END + NAVE_BAND_T,
+            NAVE_BAND_W, NAVE_SEGS, METAL_IDX,
+        ))
+    <span class="c"># Outboard washer: bites the nave&#x27;s end and the axle.</span>
+    out = <span class="n">1.0</span> <span class="k">if</span> oy &gt; <span class="n">0.0</span> <span class="k">else</span> -<span class="n">1.0</span>
+    w_mid = oy + out * (half - WASHER_BITE + WASHER_T / <span class="n">2.0</span>)
+    metal.extend(add_ring(
+        bm, (ox, w_mid, oz), AXLE_R - <span class="n">0.002</span>, WASHER_R, WASHER_T, NAVE_SEGS, METAL_IDX,
+    ))
+    <span class="c"># Spokes root inside the nave and tenon into the felloe.</span>
+    r0 = NAVE_R_MID - SPOKE_ROOT
+    r1 = RIM_MAJOR - RIM_RADIAL + SPOKE_TENON
     <span class="k">for</span> i <span class="k">in</span> range(N_SPOKES):
-        a = i * (<span class="n">2.0</span> * math.pi / N_SPOKES)
-        dx = math.cos(a)
-        dz = math.sin(a)
-        cx = loc[<span class="n">0</span>] + dx * mid_r
-        cy = loc[<span class="n">1</span>]
-        cz = loc[<span class="n">2</span>] + dz * mid_r
-        wood.extend(
-            add_box(
-                bm,
-                (cx, cy, cz),
-                (slen, SPOKE_T * <span class="n">0.85</span>, SPOKE_T),
-                WOOD_IDX,
-                euler=(<span class="n">0.0</span>, -a, <span class="n">0.0</span>),
-            )
-        )
-    metal.extend(
-        add_cyl(
-            bm,
-            loc,
-            HUB_R + <span class="n">0.010</span>,
-            <span class="n">0.016</span>,
-            <span class="n">12</span>,
-            METAL_IDX,
-            euler=(math.pi / <span class="n">2.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>),
-        )
-    )
-    metal.extend(
-        add_cyl(
-            bm,
-            (loc[<span class="n">0</span>], loc[<span class="n">1</span>] + (HUB_W * <span class="n">0.55</span> <span class="k">if</span> loc[<span class="n">1</span>] &gt; <span class="n">0</span> <span class="k">else</span> -HUB_W * <span class="n">0.55</span>), loc[<span class="n">2</span>]),
-            <span class="n">0.022</span>,
-            <span class="n">0.018</span>,
-            <span class="n">10</span>,
-            METAL_IDX,
-            euler=(math.pi / <span class="n">2.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>),
-        )
-    )
-
-
-<span class="k">def</span> build_cart_mesh(name, bevel_offset, bevel_segments):
+        a = (i + <span class="n">0.5</span>) * (<span class="n">2.0</span> * math.pi / N_SPOKES)
+        d = Vector((math.cos(a), <span class="n">0.0</span>, math.sin(a)))
+        c = Vector(loc)
+        wood.extend(add_oriented_box(bm, c + d * r0, c + d * r1,
+                                     (SPOKE_W, SPOKE_D), WOOD_IDX))
+
+
+<span class="k">def</span> build_cart_mesh(name, bevel_offset, bevel_segments, sharp_bar=<span class="k">False</span>,
+                    wide_seams=<span class="k">False</span>, short_props=<span class="k">False</span>):
+    lv = chassis_levels()
+    bed_x0 = BED_CX - BED_L / <span class="n">2.0</span>
+    bed_x1 = BED_CX + BED_L / <span class="n">2.0</span>
     bm = bmesh.new()
     <span class="k">try</span>:
-        body = []
-        wood_wheels = []
+        wood = []
         metal = []
-        axle_z = RIM_MAJOR
-        <span class="c"># The bed rides on the axle through a bolster: axle top -&gt; bolster -&gt;</span>
-        <span class="c"># bed bottom. Never let the axle interpenetrate the slats.</span>
-        bed_z = axle_z + AXLE_R + BOLSTER_H + BED_T / <span class="n">2.0</span>
-        bed_bottom = bed_z - BED_T / <span class="n">2.0</span>
-        bed_cx = <span class="n">0.06</span>
-
-        add_wheel(bm, (AXLE_X, TRACK / <span class="n">2.0</span>, axle_z), wood_wheels, metal)
-        add_wheel(bm, (AXLE_X, -TRACK / <span class="n">2.0</span>, axle_z), wood_wheels, metal)
-
-        metal.extend(
-            add_cyl(
-                bm,
-                (AXLE_X, <span class="n">0.0</span>, axle_z),
-                AXLE_R,
-                TRACK + <span class="n">0.06</span>,
-                <span class="n">10</span>,
-                METAL_IDX,
-                euler=(math.pi / <span class="n">2.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>),
-            )
-        )
+        axle_z = lv[<span class="s">&quot;axle&quot;</span>]
+        <span class="k">for</span> s <span class="k">in</span> (<span class="n">1.0</span>, -<span class="n">1.0</span>):
+            add_wheel(bm, (AXLE_X, s * TRACK / <span class="n">2.0</span>, axle_z), wood, metal)
+        axle_len = TRACK + NAVE_L + <span class="n">2.0</span> * AXLE_PROUD
+        metal.extend(add_cyl(
+            bm, (AXLE_X, <span class="n">0.0</span>, axle_z), AXLE_R, axle_len, <span class="n">12</span>, METAL_IDX,
+            euler=(math.pi / <span class="n">2.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>),
+        ))
 
-        slat_w = BED_W / N_SLATS
-        y0 = -BED_W / <span class="n">2.0</span> + slat_w / <span class="n">2.0</span>
-        <span class="k">for</span> i <span class="k">in</span> range(N_SLATS):
-            y = y0 + i * slat_w
-            body.extend(
-                add_box(
-                    bm,
-                    (bed_cx, y, bed_z),
-                    (BED_L, slat_w * <span class="n">0.88</span>, BED_T),
-                    WOOD_IDX,
-                )
-            )
-        <span class="c"># Side walls and the front board finish flush at WALL_H; the back</span>
-        <span class="c"># board is a deliberately lower tailgate.</span>
-        <span class="k">for</span> ysign <span class="k">in</span> (-<span class="n">1.0</span>, <span class="n">1.0</span>):
-            body.extend(
-                add_box(
-                    bm,
-                    (bed_cx, ysign * (BED_W / <span class="n">2.0</span> + WALL_T / <span class="n">2.0</span>), bed_z + WALL_H / <span class="n">2.0</span>),
-                    (BED_L * <span class="n">0.98</span>, WALL_T, WALL_H),
-                    WOOD_IDX,
-                )
-            )
-        body.extend(
-            add_box(
+        <span class="c"># Bolster notched onto the axle; rails on the bolster.</span>
+        wood.extend(add_span(
+            bm,
+            (AXLE_X - BOLSTER_X / <span class="n">2.0</span>, -BOLSTER_SPAN / <span class="n">2.0</span>, lv[<span class="s">&quot;bolster0&quot;</span>]),
+            (AXLE_X + BOLSTER_X / <span class="n">2.0</span>, BOLSTER_SPAN / <span class="n">2.0</span>, lv[<span class="s">&quot;bolster1&quot;</span>]),
+            WOOD_IDX,
+        ))
+        tip_x = bed_x1 + SHAFT_L
+        <span class="k">for</span> s <span class="k">in</span> (-<span class="n">1.0</span>, <span class="n">1.0</span>):
+            wood.extend(add_span(
                 bm,
-                (bed_cx + BED_L / <span class="n">2.0</span> - WALL_T / <span class="n">2.0</span>, <span class="n">0.0</span>, bed_z + WALL_H / <span class="n">2.0</span>),
-                (WALL_T, BED_W + WALL_T * <span class="n">2.0</span>, WALL_H),
+                (bed_x0 + RAIL_BACK, s * RAIL_Y - RAIL_W / <span class="n">2.0</span>, lv[<span class="s">&quot;rail0&quot;</span>]),
+                (tip_x, s * RAIL_Y + RAIL_W / <span class="n">2.0</span>, lv[<span class="s">&quot;rail1&quot;</span>]),
                 WOOD_IDX,
-            )
-        )
-        body.extend(
-            add_box(
+            ))
+            <span class="c"># Prop leg tenoned into the rail&#x27;s underside.</span>
+            leg_x = bed_x1 - LEG_BACK
+            foot_z = SHORT_PROP_Z <span class="k">if</span> short_props <span class="k">else</span> <span class="n">0.0</span>
+            wood.extend(add_span(
                 bm,
-                (bed_cx - BED_L / <span class="n">2.0</span> + WALL_T / <span class="n">2.0</span>, <span class="n">0.0</span>, bed_z + TAILGATE_H / <span class="n">2.0</span>),
-                (WALL_T, BED_W + WALL_T * <span class="n">2.0</span>, TAILGATE_H),
+                (leg_x - LEG_T / <span class="n">2.0</span>, s * RAIL_Y - LEG_T / <span class="n">2.0</span>, foot_z),
+                (leg_x + LEG_T / <span class="n">2.0</span>, s * RAIL_Y + LEG_T / <span class="n">2.0</span>,
+                 lv[<span class="s">&quot;rail0&quot;</span>] + LEG_BITE),
                 WOOD_IDX,
-            )
+            ))
+        <span class="c"># Pulling bar through both shaft tips.</span>
+        bar_half = RAIL_Y + RAIL_W / <span class="n">2.0</span> + HANDLE_PROUD
+        bar = set(add_cyl(
+            bm, (tip_x - HANDLE_BACK, <span class="n">0.0</span>, <span class="n">0.5</span> * (lv[<span class="s">&quot;rail0&quot;</span>] + lv[<span class="s">&quot;rail1&quot;</span>])),
+            HANDLE_R, <span class="n">2.0</span> * bar_half, <span class="n">12</span>, WOOD_IDX,
+            euler=(math.pi / <span class="n">2.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>),
+        ))
+        wood.extend(bar)
+
+        <span class="c"># Floor: planks across the rails.</span>
+        w = (BED_L - (N_FLOOR - <span class="n">1</span>) * FLOOR_GAP) / N_FLOOR
+        <span class="k">for</span> i <span class="k">in</span> range(N_FLOOR):
+            x0 = bed_x0 + i * (w + FLOOR_GAP)
+            wood.extend(add_span(
+                bm, (x0, -BED_W / <span class="n">2.0</span>, lv[<span class="s">&quot;floor0&quot;</span>]),
+                (x0 + w, BED_W / <span class="n">2.0</span>, lv[<span class="s">&quot;floor1&quot;</span>]), WOOD_IDX,
+            ))
+
+        <span class="c"># Side walls: stacked boards standing on the floor.</span>
+        seam = WIDE_SEAM <span class="k">if</span> wide_seams <span class="k">else</span> WALL_SEAM
+        yo = BED_W / <span class="n">2.0</span> - WALL_INSET
+        xa = bed_x0 + WALL_INSET
+        xb = bed_x1 - WALL_INSET
+        <span class="k">for</span> s <span class="k">in</span> (-<span class="n">1.0</span>, <span class="n">1.0</span>):
+            <span class="k">for</span> z0, z1 <span class="k">in</span> board_heights(lv[<span class="s">&quot;wall0&quot;</span>], WALL_H, WALL_BOARDS, seam):
+                ylo, yhi = sorted((s * yo, s * (yo - WALL_T)))
+                wood.extend(add_span(bm, (xa, ylo, z0), (xb, yhi, z1), WOOD_IDX))
+        <span class="c"># End boards between the side walls, biting into them.</span>
+        e_half = yo - WALL_T + END_BITE
+        e_z0 = lv[<span class="s">&quot;floor1&quot;</span>] - END_SEAT
+        front = board_heights(
+            e_z0, lv[<span class="s">&quot;wall1&quot;</span>] - END_DROP - e_z0, WALL_BOARDS, seam, split=END_SPLIT,
         )
-        <span class="c"># Bolsters: one sits on the axle, one forward; both carry the bed.</span>
-        <span class="k">for</span> xj <span class="k">in</span> (AXLE_X, bed_cx + BED_L * <span class="n">0.28</span>):
-            body.extend(
-                add_box(
-                    bm,
-                    (xj, <span class="n">0.0</span>, axle_z + AXLE_R + BOLSTER_H / <span class="n">2.0</span>),
-                    (<span class="n">0.055</span>, BED_W * <span class="n">0.92</span>, BOLSTER_H),
-                    WOOD_IDX,
-                )
-            )
+        tail = board_heights(e_z0, TAILGATE_H, <span class="n">1</span>, seam)
+        <span class="k">for</span> boards, xs <span class="k">in</span> (
+            (front, (xb - END_INSET - WALL_T, xb - END_INSET)),
+            (tail, (xa + END_INSET, xa + END_INSET + WALL_T)),
+        ):
+            <span class="k">for</span> z0, z1 <span class="k">in</span> boards:
+                wood.extend(add_span(
+                    bm, (xs[<span class="n">0</span>], -e_half, z0), (xs[<span class="n">1</span>], e_half, z1), WOOD_IDX,
+                ))
+
+        <span class="c"># Iron corner straps on the side walls&#x27; corners.</span>
+        sz0 = lv[<span class="s">&quot;floor1&quot;</span>] + STRAP_MARGIN
+        sz1 = lv[<span class="s">&quot;wall1&quot;</span>] - STRAP_MARGIN
+        <span class="k">for</span> cx, sx <span class="k">in</span> ((xb, <span class="n">1.0</span>), (xa, -<span class="n">1.0</span>)):
+            <span class="k">for</span> sy <span class="k">in</span> (-<span class="n">1.0</span>, <span class="n">1.0</span>):
+                metal.extend(add_l_strap(bm, (cx, sy * yo), sx, sy, sz0, sz1, METAL_IDX))
+
+        bm.edges.index_update()
+
+        <span class="k">def</span> sharp(edge, idx):
+            <span class="k">if</span> len(edge.link_faces) != <span class="n">2</span>:
+                <span class="k">return</span> <span class="k">False</span>
+            <span class="c"># --sharp-bar leaves the pull bar&#x27;s rims square: 48 triangles</span>
+            <span class="c"># short, well inside the triangle band, so only the edge</span>
+            <span class="c"># budget can see it. Skipping the whole iron pass dropped</span>
+            <span class="c"># 1200 and tripped the triangle floor instead.</span>
+            <span class="k">if</span> sharp_bar <span class="k">and</span> all(v <span class="k">in</span> bar <span class="k">for</span> v <span class="k">in</span> edge.verts):
+                <span class="k">return</span> <span class="k">False</span>
+            <span class="k">if</span> any(f.material_index != idx <span class="k">for</span> f <span class="k">in</span> edge.link_faces):
+                <span class="k">return</span> <span class="k">False</span>
+            <span class="k">return</span> edge.calc_face_angle(<span class="n">0.0</span>) &gt; BEVEL_MIN_ANGLE
 
-        <span class="c"># Shafts hang under the bed front: the back end embeds 6 mm into the</span>
-        <span class="c"># slat bottom and never pokes through the bed floor.</span>
-        shaft_x = bed_cx + BED_L / <span class="n">2.0</span> + SHAFT_L / <span class="n">2.0</span> - <span class="n">0.04</span>
-        shaft_z = (
-            bed_bottom + <span class="n">0.006</span> - SHAFT_T / <span class="n">2.0</span>
-            - math.sin(SHAFT_PITCH) * (SHAFT_L / <span class="n">2.0</span>)
-        )
-        <span class="k">for</span> ysign <span class="k">in</span> (-<span class="n">1.0</span>, <span class="n">1.0</span>):
-            body.extend(
-                add_box(
-                    bm,
-                    (shaft_x, ysign * <span class="n">0.12</span>, shaft_z),
-                    (SHAFT_L, SHAFT_T, SHAFT_T),
-                    WOOD_IDX,
-                    euler=(<span class="n">0.0</span>, SHAFT_PITCH, <span class="n">0.0</span>),
-                )
+        <span class="k">if</span> bevel_offset &gt; <span class="n">0.0</span>:
+            edges = sorted(
+                (e <span class="k">for</span> e <span class="k">in</span> bm.edges <span class="k">if</span> sharp(e, WOOD_IDX)), key=<span class="k">lambda</span> e: e.index
             )
-            metal.extend(
-                add_box(
-                    bm,
-                    (bed_cx + BED_L / <span class="n">2.0</span> - <span class="n">0.02</span>, ysign * <span class="n">0.12</span>, bed_bottom - IRON_T / <span class="n">2.0</span>),
-                    (<span class="n">0.05</span>, <span class="n">0.042</span>, IRON_T),
-                    METAL_IDX,
-                )
+            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>, material=WOOD_IDX,
             )
-
-        <span class="c"># Tie-down plates sit on top of the bed floor, fully inboard of the</span>
-        <span class="c"># walls — visible, not buried inside the slats.</span>
-        <span class="k">for</span> sx, sy <span class="k">in</span> (
-            (bed_cx - BED_L / <span class="n">2.0</span> + <span class="n">0.055</span>, -BED_W / <span class="n">2.0</span> + <span class="n">0.055</span>),
-            (bed_cx - BED_L / <span class="n">2.0</span> + <span class="n">0.055</span>, BED_W / <span class="n">2.0</span> - <span class="n">0.055</span>),
-            (bed_cx + BED_L / <span class="n">2.0</span> - <span class="n">0.055</span>, -BED_W / <span class="n">2.0</span> + <span class="n">0.055</span>),
-            (bed_cx + BED_L / <span class="n">2.0</span> - <span class="n">0.055</span>, BED_W / <span class="n">2.0</span> - <span class="n">0.055</span>),
-        ):
-            metal.extend(
-                add_box(
-                    bm,
-                    (sx, sy, bed_z + BED_T / <span class="n">2.0</span> + IRON_T / <span class="n">2.0</span>),
-                    (<span class="n">0.055</span>, <span class="n">0.055</span>, IRON_T),
-                    METAL_IDX,
-                )
+            bm.edges.index_update()
+            edges = sorted(
+                (e <span class="k">for</span> e <span class="k">in</span> bm.edges <span class="k">if</span> sharp(e, METAL_IDX)), key=<span class="k">lambda</span> e: e.index
             )
-
-        <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> body <span class="k">for</span> e <span class="k">in</span> v.link_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>,
+            bmesh.ops.bevel(
+                bm, geom=edges, offset=IRON_BEVEL, segments=<span class="n">1</span>, profile=<span class="n">0.5</span>,
+                affect=<span class="s">&quot;EDGES&quot;</span>, clamp_overlap=<span class="k">True</span>, material=METAL_IDX,
             )
-            <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
+        finish_caps(bm)
 
         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]
@@ -813,25 +1009,75 @@ <h2>Source</h2>
             v.co.x -= cx
             v.co.y -= cy
             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>
 
         pack_uvs(bm)
         bmesh.ops.recalc_face_normals(bm, faces=list(bm.faces))
+        <span class="c"># Smooth across the felloe&#x27;s, nave&#x27;s and axle&#x27;s facets; hard at every</span>
+        <span class="c"># chamfer and material boundary, so a board stays a board.</span>
         <span class="k">for</span> face <span class="k">in</span> bm.faces:
-            face.smooth = <span class="k">False</span>
+            face.smooth = <span class="k">True</span>
+        <span class="k">for</span> edge <span class="k">in</span> bm.edges:
+            edge.smooth = <span class="k">True</span>
+            <span class="k">if</span> len(edge.link_faces) == <span class="n">2</span>:
+                f0, f1 = edge.link_faces
+                <span class="k">if</span> (f0.material_index != f1.material_index
+                        <span class="k">or</span> edge.calc_face_angle(<span class="n">0.0</span>) &gt; math.radians(<span class="n">35.0</span>)):
+                    edge.smooth = <span class="k">False</span>
         me = bpy.data.meshes.new(name)
         bm.to_mesh(me)
         me.update()
-        <span class="k">for</span> poly <span class="k">in</span> me.polygons:
-            poly.use_smooth = <span class="k">False</span>
     <span class="k">finally</span>:
         bm.free()
+    paint_planks(me)
     out = bpy.data.objects.new(name, me)
     bpy.context.collection.objects.link(out)
     <span class="k">return</span> out
 
 
+<span class="k">def</span> _long_axis(pts):
+    <span class="s">&quot;&quot;&quot;Principal axis of a point set, by power iteration on its covariance.&quot;&quot;&quot;</span>
+    c = sum(pts, Vector()) / len(pts)
+    cov = [[<span class="n">0.0</span>] * <span class="n">3</span> <span class="k">for</span> _ <span class="k">in</span> range(<span class="n">3</span>)]
+    <span class="k">for</span> p <span class="k">in</span> pts:
+        d = p - c
+        <span class="k">for</span> i <span class="k">in</span> range(<span class="n">3</span>):
+            <span class="k">for</span> j <span class="k">in</span> range(<span class="n">3</span>):
+                cov[i][j] += d[i] * d[j]
+    v = Vector((<span class="n">1.0</span>, <span class="n">0.3</span>, <span class="n">0.1</span>))
+    <span class="k">for</span> _ <span class="k">in</span> range(<span class="n">30</span>):
+        w = Vector([sum(cov[i][j] * v[j] <span class="k">for</span> j <span class="k">in</span> range(<span class="n">3</span>)) <span class="k">for</span> i <span class="k">in</span> range(<span class="n">3</span>)])
+        <span class="k">if</span> w.length &lt; <span class="n">1e-12</span>:
+            <span class="k">break</span>
+        v = w.normalized()
+    <span class="k">return</span> v
+
+
+<span class="k">def</span> paint_planks(me):
+    <span class="s">&quot;&quot;&quot;Per-shell ``PlankTone`` and ``GrainDir`` face attributes for the wood shader.
+
+    Every plank, board, rail, leg, spoke and felloe is its own shell, so
+    each gets one seeded tone and grain along its own long axis.
+    &quot;&quot;&quot;</span>
+    tone = [<span class="n">0.5</span>] * len(me.polygons)
+    grain = [(<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">1.0</span>)] * len(me.polygons)
+    owner = {}
+    rng = random.Random(TONE_SEED)
+    <span class="k">for</span> g <span class="k">in</span> shell_groups(me):
+        pts = [me.vertices[i].co.copy() <span class="k">for</span> i <span class="k">in</span> g]
+        d = _long_axis(pts) <span class="k">if</span> len(pts) &gt; <span class="n">2</span> <span class="k">else</span> Vector((<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">1.0</span>))
+        t = <span class="n">0.5</span> + rng.uniform(-PLANK_TONE_JITTER, PLANK_TONE_JITTER)
+        <span class="k">for</span> i <span class="k">in</span> g:
+            owner[i] = (t, tuple(d))
+    <span class="k">for</span> poly <span class="k">in</span> me.polygons:
+        t, d = owner[poly.vertices[<span class="n">0</span>]]
+        tone[poly.index] = t
+        grain[poly.index] = d
+    a = me.attributes.new(<span class="s">&quot;PlankTone&quot;</span>, <span class="s">&quot;FLOAT&quot;</span>, <span class="s">&quot;FACE&quot;</span>)
+    a.data.foreach_set(<span class="s">&quot;value&quot;</span>, tone)
+    b = me.attributes.new(<span class="s">&quot;GrainDir&quot;</span>, <span class="s">&quot;FLOAT_VECTOR&quot;</span>, <span class="s">&quot;FACE&quot;</span>)
+    b.data.foreach_set(<span class="s">&quot;vector&quot;</span>, [c <span class="k">for</span> v <span class="k">in</span> grain <span class="k">for</span> c <span class="k">in</span> v])
+
+
 <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>
@@ -862,6 +1108,90 @@ <h2>Source</h2>
     <span class="k">return</span> mat
 
 
+<span class="k">def</span> _sock(sockets, identifier):
+    <span class="s">&quot;&quot;&quot;A Mix-node socket by identifier; its A/B/Result names repeat per type.&quot;&quot;&quot;</span>
+    <span class="k">return</span> next(sk <span class="k">for</span> sk <span class="k">in</span> sockets <span class="k">if</span> sk.identifier == identifier)
+
+
+<span class="k">def</span> wood_material(name):
+    <span class="s">&quot;&quot;&quot;Grain along each board and rail (``GrainDir``), tone per piece (``PlankTone``).
+
+    Copied from showcase/wheelbarrow (do not import across pieces).
+    &quot;&quot;&quot;</span>
+    mat = bpy.data.materials.new(name)
+    mat.use_nodes = <span class="k">True</span>
+    nt = mat.node_tree
+    bsdf = nt.nodes[<span class="s">&quot;Principled BSDF&quot;</span>]
+    coord = nt.nodes.new(<span class="s">&quot;ShaderNodeTexCoord&quot;</span>)
+    gdir = nt.nodes.new(<span class="s">&quot;ShaderNodeAttribute&quot;</span>)
+    gdir.attribute_name = <span class="s">&quot;GrainDir&quot;</span>
+    tone = nt.nodes.new(<span class="s">&quot;ShaderNodeAttribute&quot;</span>)
+    tone.attribute_name = <span class="s">&quot;PlankTone&quot;</span>
+    dot = nt.nodes.new(<span class="s">&quot;ShaderNodeVectorMath&quot;</span>)
+    dot.operation = <span class="s">&quot;DOT_PRODUCT&quot;</span>
+    nt.links.new(coord.outputs[<span class="s">&quot;Object&quot;</span>], dot.inputs[<span class="n">0</span>])
+    nt.links.new(gdir.outputs[<span class="s">&quot;Vector&quot;</span>], dot.inputs[<span class="n">1</span>])
+    squash = nt.nodes.new(<span class="s">&quot;ShaderNodeMath&quot;</span>)
+    squash.operation = <span class="s">&quot;MULTIPLY&quot;</span>
+    squash.inputs[<span class="n">1</span>].default_value = <span class="n">0.94</span>
+    nt.links.new(dot.outputs[<span class="s">&quot;Value&quot;</span>], squash.inputs[<span class="n">0</span>])
+    along = nt.nodes.new(<span class="s">&quot;ShaderNodeVectorMath&quot;</span>)
+    along.operation = <span class="s">&quot;SCALE&quot;</span>
+    nt.links.new(gdir.outputs[<span class="s">&quot;Vector&quot;</span>], along.inputs[<span class="n">0</span>])
+    nt.links.new(squash.outputs[<span class="s">&quot;Value&quot;</span>], along.inputs[<span class="s">&quot;Scale&quot;</span>])
+    grain_co = nt.nodes.new(<span class="s">&quot;ShaderNodeVectorMath&quot;</span>)
+    grain_co.operation = <span class="s">&quot;SUBTRACT&quot;</span>
+    nt.links.new(coord.outputs[<span class="s">&quot;Object&quot;</span>], grain_co.inputs[<span class="n">0</span>])
+    nt.links.new(along.outputs[<span class="s">&quot;Vector&quot;</span>], grain_co.inputs[<span class="n">1</span>])
+    shift = nt.nodes.new(<span class="s">&quot;ShaderNodeVectorMath&quot;</span>)
+    shift.operation = <span class="s">&quot;ADD&quot;</span>
+    nt.links.new(grain_co.outputs[<span class="s">&quot;Vector&quot;</span>], shift.inputs[<span class="n">0</span>])
+    nt.links.new(tone.outputs[<span class="s">&quot;Fac&quot;</span>], shift.inputs[<span class="n">1</span>])
+    noise = nt.nodes.new(<span class="s">&quot;ShaderNodeTexNoise&quot;</span>)
+    noise.inputs[<span class="s">&quot;Scale&quot;</span>].default_value = WOOD_GRAIN_SCALE
+    noise.inputs[<span class="s">&quot;Detail&quot;</span>].default_value = <span class="n">6.0</span>
+    noise.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.62</span>
+    nt.links.new(shift.outputs[<span class="s">&quot;Vector&quot;</span>], noise.inputs[<span class="s">&quot;Vector&quot;</span>])
+    ramp = nt.nodes.new(<span class="s">&quot;ShaderNodeValToRGB&quot;</span>)
+    ramp.color_ramp.elements[<span class="n">0</span>].position = <span class="n">0.30</span>
+    ramp.color_ramp.elements[<span class="n">0</span>].color = (<span class="n">0.13</span>, <span class="n">0.058</span>, <span class="n">0.020</span>, <span class="n">1.0</span>)
+    ramp.color_ramp.elements[<span class="n">1</span>].position = <span class="n">0.72</span>
+    ramp.color_ramp.elements[<span class="n">1</span>].color = (<span class="n">0.40</span>, <span class="n">0.20</span>, <span class="n">0.075</span>, <span class="n">1.0</span>)
+    nt.links.new(noise.outputs[<span class="s">&quot;Fac&quot;</span>], ramp.inputs[<span class="s">&quot;Fac&quot;</span>])
+    gain = nt.nodes.new(<span class="s">&quot;ShaderNodeMath&quot;</span>)
+    gain.operation = <span class="s">&quot;MULTIPLY_ADD&quot;</span>
+    gain.inputs[<span class="n">1</span>].default_value = <span class="n">1.1</span>
+    gain.inputs[<span class="n">2</span>].default_value = <span class="n">0.45</span>
+    nt.links.new(tone.outputs[<span class="s">&quot;Fac&quot;</span>], gain.inputs[<span class="n">0</span>])
+    mix = nt.nodes.new(<span class="s">&quot;ShaderNodeMix&quot;</span>)
+    mix.data_type = <span class="s">&quot;RGBA&quot;</span>
+    mix.blend_type = <span class="s">&quot;MULTIPLY&quot;</span>
+    _sock(mix.inputs, <span class="s">&quot;Factor_Float&quot;</span>).default_value = <span class="n">1.0</span>
+    nt.links.new(ramp.outputs[<span class="s">&quot;Color&quot;</span>], _sock(mix.inputs, <span class="s">&quot;A_Color&quot;</span>))
+    nt.links.new(gain.outputs[<span class="s">&quot;Value&quot;</span>], _sock(mix.inputs, <span class="s">&quot;B_Color&quot;</span>))
+    nt.links.new(_sock(mix.outputs, <span class="s">&quot;Result_Color&quot;</span>), bsdf.inputs[<span class="s">&quot;Base Color&quot;</span>])
+    rough = nt.nodes.new(<span class="s">&quot;ShaderNodeMapRange&quot;</span>)
+    rough.inputs[<span class="s">&quot;To Min&quot;</span>].default_value = <span class="n">0.72</span>
+    rough.inputs[<span class="s">&quot;To Max&quot;</span>].default_value = <span class="n">0.52</span>
+    nt.links.new(noise.outputs[<span class="s">&quot;Fac&quot;</span>], rough.inputs[<span class="s">&quot;Value&quot;</span>])
+    nt.links.new(rough.outputs[<span class="s">&quot;Result&quot;</span>], bsdf.inputs[<span class="s">&quot;Roughness&quot;</span>])
+    <span class="k">return</span> mat
+
+
+<span class="k">def</span> cart_materials():
+    <span class="s">&quot;&quot;&quot;(wood, iron): shared by the check, the render and inspection.
+
+    Forged iron, dark and rusted. The first build&#x27;s metallic 1.0 at 0.50
+    roughness rendered the tyres as bright polished steel beside the wood.
+    &quot;&quot;&quot;</span>
+    wood = wood_material(<span class="s">&quot;CartWood&quot;</span>)
+    metal = principled(
+        <span class="s">&quot;CartIron&quot;</span>, (<span class="n">0.17</span>, <span class="n">0.165</span>, <span class="n">0.155</span>, <span class="n">1.0</span>), <span class="n">0.80</span>, <span class="n">0.46</span>,
+        noise_scale=<span class="n">18.0</span>, wear=(<span class="n">0.20</span>, <span class="n">0.085</span>, <span class="n">0.032</span>, <span class="n">1.0</span>),
+    )
+    <span class="k">return</span> wood, metal
+
+
 <span class="k">def</span> assign_slots(obj, wood, metal):
     mats = obj.data.materials
     wanted = (wood, metal)
@@ -881,6 +1211,11 @@ <h2>Source</h2>
 
 
 <span class="k">def</span> uv_stats(mesh):
+    <span class="s">&quot;&quot;&quot;UV bounds and the summed pairwise AABB overlap area.
+
+    A sweep over boxes sorted by min u: the same pairs and the same sum as
+    the all-pairs loop, without its quadratic cost on a 4k-face piece.
+    &quot;&quot;&quot;</span>
     uv = mesh.uv_layers.active
     <span class="k">if</span> uv <span class="k">is</span> <span class="k">None</span>:
         <span class="k">return</span> <span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">1.0</span>, <span class="n">1.0</span>, <span class="n">0</span>, <span class="n">1.0</span>
@@ -892,16 +1227,17 @@ <h2>Source</h2>
         pu = [data[i].uv[<span class="n">0</span>] <span class="k">for</span> i <span class="k">in</span> poly.loop_indices]
         pv = [data[i].uv[<span class="n">1</span>] <span class="k">for</span> i <span class="k">in</span> poly.loop_indices]
         aabbs.append((min(pu), min(pv), max(pu), max(pv)))
+    aabbs.sort()
     overlap = <span class="n">0.0</span>
     <span class="k">for</span> i <span class="k">in</span> range(len(aabbs)):
         a = aabbs[i]
         <span class="k">for</span> j <span class="k">in</span> range(i + <span class="n">1</span>, len(aabbs)):
             b = aabbs[j]
-            x0 = max(a[<span class="n">0</span>], b[<span class="n">0</span>])
+            <span class="k">if</span> b[<span class="n">0</span>] &gt;= a[<span class="n">2</span>]:
+                <span class="k">break</span>
             y0 = max(a[<span class="n">1</span>], b[<span class="n">1</span>])
-            x1 = min(a[<span class="n">2</span>], b[<span class="n">2</span>])
             y1 = min(a[<span class="n">3</span>], b[<span class="n">3</span>])
-            overlap += max(<span class="n">0.0</span>, x1 - x0) * max(<span class="n">0.0</span>, y1 - y0)
+            overlap += (min(a[<span class="n">2</span>], b[<span class="n">2</span>]) - b[<span class="n">0</span>]) * max(<span class="n">0.0</span>, y1 - y0)
     <span class="k">return</span> min(us), min(vs), max(us), max(vs), overlap, len(aabbs)
 
 
@@ -965,7 +1301,7 @@ <h2>Source</h2>
     groups = {}
     <span class="k">for</span> i <span class="k">in</span> range(len(me.vertices)):
         groups.setdefault(find(i), []).append(i)
-    <span class="k">return</span> sorted(groups.values(), key=<span class="k">lambda</span> g: -len(g))
+    <span class="k">return</span> sorted(groups.values(), key=<span class="k">lambda</span> g: (-len(g), min(g)))
 
 
 <span class="k">def</span> shell_box(me, idxs):
@@ -977,6 +1313,14 @@ <h2>Source</h2>
     }
 
 
+<span class="k">def</span> shell_mat(me, idxs):
+    member = set(idxs)
+    <span class="k">for</span> p <span class="k">in</span> me.polygons:
+        <span class="k">if</span> p.vertices[<span class="n">0</span>] <span class="k">in</span> member:
+            <span class="k">return</span> p.material_index
+    <span class="k">return</span> <span class="k">None</span>
+
+
 <span class="k">def</span> coplanar_zfight_pairs(me, groups):
     <span class="s">&quot;&quot;&quot;Coplanar face pairs from *different shells* — the z-fighting budget.
 
@@ -985,7 +1329,9 @@ <h2>Source</h2>
     counting those makes the budget unsatisfiable rather than meaningful.
     Z-fighting is two separate bodies landing on one plane, which is
     exactly a cross-shell pair. Combinatorics and constants copied from
-    showcase/hay-bale (do not import across pieces).
+    showcase/hay-bale (do not import across pieces); candidate pairs come
+    from a KD-tree range query at COPLANAR_CENTRE_MAX, the same pairs the
+    all-pairs loop visits.
     &quot;&quot;&quot;</span>
     owner = {}
     <span class="k">for</span> si, comp <span class="k">in</span> enumerate(groups):
@@ -993,15 +1339,18 @@ <h2>Source</h2>
             owner[vi] = si
     faces = [(p.normal.copy(), p.center.copy(), owner.get(p.vertices[<span class="n">0</span>], -<span class="n">1</span>))
              <span class="k">for</span> p <span class="k">in</span> me.polygons]
+    kd = KDTree(len(faces))
+    <span class="k">for</span> i, (_n, c, _s) <span class="k">in</span> enumerate(faces):
+        kd.insert(c, i)
+    kd.balance()
     hits = <span class="n">0</span>
-    <span class="k">for</span> i <span class="k">in</span> range(len(faces)):
-        ni, ci, si = faces[i]
-        <span class="k">for</span> j <span class="k">in</span> range(i + <span class="n">1</span>, len(faces)):
+    <span class="k">for</span> i, (ni, ci, si) <span class="k">in</span> enumerate(faces):
+        <span class="k">for</span> _co, j, _d <span class="k">in</span> kd.find_range(ci, COPLANAR_CENTRE_MAX):
+            <span class="k">if</span> j &lt;= i:
+                <span class="k">continue</span>
             nj, cj, sj = faces[j]
             <span class="k">if</span> si == sj:
                 <span class="k">continue</span>
-            <span class="k">if</span> (ci - cj).length &gt; COPLANAR_CENTRE_MAX:
-                <span class="k">continue</span>
             <span class="k">if</span> abs(abs(ni.dot(nj)) - <span class="n">1.0</span>) &gt; COPLANAR_NORMAL_EPS:
                 <span class="k">continue</span>
             <span class="k">if</span> abs(ni.dot(cj - ci)) &gt; COPLANAR_PLANE_EPS:
@@ -1014,7 +1363,7 @@ <h2>Source</h2>
     <span class="s">&quot;&quot;&quot;(rim, tyre) shell index pairs for each wheel, keyed by track side.
 
     Identified from the generated mesh by geometry — a shell centred on the
-    axle line whose YZ extent is a full disc — never from a construction
+    axle line whose XZ extent is a full disc — never from a construction
     constant. The tyre is the metal-indexed member of the pair.
     &quot;&quot;&quot;</span>
     metal = set()
@@ -1096,11 +1445,12 @@ <h2>Source</h2>
 
 
 <span class="k">def</span> move_one_wheel(me, delta):
-    <span class="s">&quot;&quot;&quot;Falsifier surgery: translate the +Y wheel only (rim, tyre, spokes).
+    <span class="s">&quot;&quot;&quot;Falsifier surgery: translate the +Y wheel only, as one body.
 
-    Everything whose vertices lie on the +Y side of the axle centreline and
-    within the wheel&#x27;s radius, so the assembly moves as one body and the
-    opposite wheel still grounds the AABB.
+    Moves every shell lying wholly inside that wheel&#x27;s envelope — felloe,
+    tyre, nave, bands, washer, spokes — so the assembly stays intact and
+    the opposite wheel still grounds the AABB. The axle runs across both
+    wheels, so it is never wholly inside one and stays put.
     &quot;&quot;&quot;</span>
     groups = shell_groups(me)
     parts = wheel_shells(me, groups).get(<span class="n">1</span>)
@@ -1108,19 +1458,165 @@ <h2>Source</h2>
         <span class="k">return</span>
     b = shell_box(me, groups[parts[<span class="s">&quot;tyre&quot;</span>]])
     cx, cz = _wheel_centre(me, groups, parts[<span class="s">&quot;rim&quot;</span>])
-    y_lo, y_hi = b[<span class="s">&quot;ymin&quot;</span>] - <span class="n">0.02</span>, b[<span class="s">&quot;ymax&quot;</span>] + <span class="n">0.02</span>
-    r_max = <span class="n">0.5</span> * (b[<span class="s">&quot;xmax&quot;</span>] - b[<span class="s">&quot;xmin&quot;</span>]) + <span class="n">1e-4</span>
-    <span class="k">for</span> v <span class="k">in</span> me.vertices:
-        <span class="k">if</span> <span class="k">not</span> (y_lo &lt;= v.co.y &lt;= y_hi):
+    wy = <span class="n">0.5</span> * (b[<span class="s">&quot;ymin&quot;</span>] + b[<span class="s">&quot;ymax&quot;</span>])
+    r_max = <span class="n">0.5</span> * (b[<span class="s">&quot;xmax&quot;</span>] - b[<span class="s">&quot;xmin&quot;</span>]) + <span class="n">1e-3</span>
+    <span class="k">for</span> g <span class="k">in</span> groups:
+        inside = all(
+            math.hypot(me.vertices[i].co.x - cx, me.vertices[i].co.z - cz) &lt;= r_max
+            <span class="k">and</span> abs(me.vertices[i].co.y - wy) &lt;= NAVE_L / <span class="n">2.0</span> + <span class="n">0.02</span>
+            <span class="k">for</span> i <span class="k">in</span> g
+        )
+        <span class="k">if</span> <span class="k">not</span> inside:
             <span class="k">continue</span>
-        <span class="k">if</span> math.hypot(v.co.x - cx, v.co.z - cz) &gt; r_max:
+        <span class="k">for</span> i <span class="k">in</span> g:
+            co = me.vertices[i].co
+            co.x += delta[<span class="n">0</span>]
+            co.y += delta[<span class="n">1</span>]
+            co.z += delta[<span class="n">2</span>]
+    me.update()
+
+
+<span class="k">def</span> lift_bed(me, dz):
+    <span class="s">&quot;&quot;&quot;Falsifier surgery: raise the box — planks, walls, straps — off its rails.
+
+    The box is every shell whose floor sits at or above the rails&#x27; top less
+    the floor&#x27;s bite, read off the mesh. Lifted by more than that bite, the
+    planks clear the rails and the box is joined to nothing below it.
+    &quot;&quot;&quot;</span>
+    groups = shell_groups(me)
+    rails = [g <span class="k">for</span> g <span class="k">in</span> groups
+             <span class="k">if</span> shell_mat(me, g) == WOOD_IDX
+             <span class="k">and</span> (shell_box(me, g)[<span class="s">&quot;xmax&quot;</span>] - shell_box(me, g)[<span class="s">&quot;xmin&quot;</span>]) &gt; BED_L + <span class="n">0.3</span>]
+    <span class="k">if</span> <span class="k">not</span> rails:
+        <span class="k">return</span>
+    rail_top = max(shell_box(me, g)[<span class="s">&quot;zmax&quot;</span>] <span class="k">for</span> g <span class="k">in</span> rails)
+    floor = rail_top - FLOOR_BITE - <span class="n">1e-4</span>
+    <span class="k">for</span> g <span class="k">in</span> groups:
+        <span class="k">if</span> shell_box(me, g)[<span class="s">&quot;zmin&quot;</span>] &lt; floor:
             <span class="k">continue</span>
-        v.co.x += delta[<span class="n">0</span>]
-        v.co.y += delta[<span class="n">1</span>]
-        v.co.z += delta[<span class="n">2</span>]
+        <span class="k">for</span> i <span class="k">in</span> g:
+            me.vertices[i].co.z += dz
     me.update()
 
 
+<span class="k">def</span> support_audit(me, groups, wheels):
+    <span class="s">&quot;&quot;&quot;Floor contact per named support: each tyre and each prop leg.
+
+    Legs are the wood shells that stand tall and thin; counted, so a leg a
+    classifier drops cannot pass vacuously.
+    &quot;&quot;&quot;</span>
+    out = {}
+    <span class="k">for</span> side, parts <span class="k">in</span> sorted(wheels.items()):
+        tb = shell_box(me, groups[parts[<span class="s">&quot;tyre&quot;</span>]])
+        out[<span class="s">&quot;tyre+Y&quot;</span> <span class="k">if</span> side &gt; <span class="n">0</span> <span class="k">else</span> <span class="s">&quot;tyre-Y&quot;</span>] = tb[<span class="s">&quot;zmin&quot;</span>]
+    legs = []
+    <span class="k">for</span> g <span class="k">in</span> groups:
+        <span class="k">if</span> shell_mat(me, g) != WOOD_IDX:
+            <span class="k">continue</span>
+        b = shell_box(me, g)
+        <span class="k">if</span> (b[<span class="s">&quot;zmax&quot;</span>] - b[<span class="s">&quot;zmin&quot;</span>]) &gt; <span class="n">0.3</span> <span class="k">and</span> (b[<span class="s">&quot;xmax&quot;</span>] - b[<span class="s">&quot;xmin&quot;</span>]) &lt; <span class="n">0.06</span> \
+                <span class="k">and</span> (b[<span class="s">&quot;ymax&quot;</span>] - b[<span class="s">&quot;ymin&quot;</span>]) &lt; <span class="n">0.06</span>:
+            legs.append(b)
+    legs.sort(key=<span class="k">lambda</span> b: b[<span class="s">&quot;ymin&quot;</span>])
+    <span class="k">for</span> i, b <span class="k">in</span> enumerate(legs):
+        out[<span class="s">f&quot;</span><span class="s">leg</span>{i}<span class="s">&quot;</span>] = b[<span class="s">&quot;zmin&quot;</span>]
+    <span class="k">return</span> out, len(legs)
+
+
+<span class="k">def</span> wall_board_audit(me, groups):
+    <span class="s">&quot;&quot;&quot;Side-wall boards per side and the seam between each stacked pair.
+
+    Boards are the wood shells that run the bed&#x27;s length, are one board
+    thick, and stand above the rails — read off the mesh.
+    &quot;&quot;&quot;</span>
+    rails_top = -<span class="n">1.0</span>
+    <span class="k">for</span> g <span class="k">in</span> groups:
+        b = shell_box(me, g)
+        <span class="k">if</span> shell_mat(me, g) == WOOD_IDX <span class="k">and</span> (b[<span class="s">&quot;xmax&quot;</span>] - b[<span class="s">&quot;xmin&quot;</span>]) &gt; BED_L + <span class="n">0.3</span>:
+            rails_top = max(rails_top, b[<span class="s">&quot;zmax&quot;</span>])
+    sides = {-<span class="n">1</span>: [], <span class="n">1</span>: []}
+    <span class="k">for</span> g <span class="k">in</span> groups:
+        <span class="k">if</span> shell_mat(me, g) != WOOD_IDX:
+            <span class="k">continue</span>
+        b = shell_box(me, g)
+        <span class="k">if</span> (b[<span class="s">&quot;xmax&quot;</span>] - b[<span class="s">&quot;xmin&quot;</span>]) &lt; <span class="n">0.8</span> * BED_L:
+            <span class="k">continue</span>
+        <span class="k">if</span> (b[<span class="s">&quot;ymax&quot;</span>] - b[<span class="s">&quot;ymin&quot;</span>]) &gt; <span class="n">2.0</span> * WALL_T <span class="k">or</span> b[<span class="s">&quot;zmin&quot;</span>] &lt; rails_top:
+            <span class="k">continue</span>
+        sides[<span class="n">1</span> <span class="k">if</span> b[<span class="s">&quot;ymin&quot;</span>] &gt; <span class="n">0</span> <span class="k">else</span> -<span class="n">1</span>].append(b)
+    seams = []
+    <span class="k">for</span> boards <span class="k">in</span> sides.values():
+        boards.sort(key=<span class="k">lambda</span> b: b[<span class="s">&quot;zmin&quot;</span>])
+        <span class="k">for</span> lo, hi <span class="k">in</span> zip(boards, boards[<span class="n">1</span>:]):
+            seams.append(hi[<span class="s">&quot;zmin&quot;</span>] - lo[<span class="s">&quot;zmax&quot;</span>])
+    <span class="k">return</span> len(sides[-<span class="n">1</span>]), len(sides[<span class="n">1</span>]), seams
+
+
+<span class="k">def</span> contact_components(me, groups):
+    <span class="s">&quot;&quot;&quot;Components of the shells&#x27; BVH-overlap graph.
+
+    Every joint in the piece is a bite, so joined members&#x27; surfaces cross.
+    One component means every member is attached to the assembly; a second
+    is a part — or a whole sub-assembly — hanging in the air.
+    &quot;&quot;&quot;</span>
+    verts = [v.co.copy() <span class="k">for</span> v <span class="k">in</span> me.vertices]
+    owner = {}
+    <span class="k">for</span> si, g <span class="k">in</span> enumerate(groups):
+        <span class="k">for</span> vi <span class="k">in</span> g:
+            owner[vi] = si
+    polys = [[] <span class="k">for</span> _ <span class="k">in</span> groups]
+    <span class="k">for</span> p <span class="k">in</span> me.polygons:
+        polys[owner[p.vertices[<span class="n">0</span>]]].append(tuple(p.vertices))
+    trees = [BVHTree.FromPolygons(verts, ps) <span class="k">if</span> ps <span class="k">else</span> <span class="k">None</span> <span class="k">for</span> ps <span class="k">in</span> polys]
+    boxes = [shell_box(me, g) <span class="k">for</span> g <span class="k">in</span> groups]
+    parent = list(range(len(groups)))
+
+    <span class="k">def</span> find(a):
+        <span class="k">while</span> parent[a] != a:
+            parent[a] = parent[parent[a]]
+            a = parent[a]
+        <span class="k">return</span> a
+
+    pad = <span class="n">1e-4</span>
+    <span class="k">for</span> i <span class="k">in</span> range(len(groups)):
+        <span class="k">for</span> j <span class="k">in</span> range(i + <span class="n">1</span>, len(groups)):
+            a, b = boxes[i], boxes[j]
+            <span class="k">if</span> (a[<span class="s">&quot;xmin&quot;</span>] &gt; b[<span class="s">&quot;xmax&quot;</span>] + pad <span class="k">or</span> b[<span class="s">&quot;xmin&quot;</span>] &gt; a[<span class="s">&quot;xmax&quot;</span>] + pad
+                    <span class="k">or</span> a[<span class="s">&quot;ymin&quot;</span>] &gt; b[<span class="s">&quot;ymax&quot;</span>] + pad <span class="k">or</span> b[<span class="s">&quot;ymin&quot;</span>] &gt; a[<span class="s">&quot;ymax&quot;</span>] + pad
+                    <span class="k">or</span> a[<span class="s">&quot;zmin&quot;</span>] &gt; b[<span class="s">&quot;zmax&quot;</span>] + pad <span class="k">or</span> b[<span class="s">&quot;zmin&quot;</span>] &gt; a[<span class="s">&quot;zmax&quot;</span>] + pad):
+                <span class="k">continue</span>
+            <span class="k">if</span> trees[i] <span class="k">is</span> <span class="k">None</span> <span class="k">or</span> trees[j] <span class="k">is</span> <span class="k">None</span>:
+                <span class="k">continue</span>
+            <span class="k">if</span> trees[i].overlap(trees[j]):
+                ra, rb = find(i), find(j)
+                <span class="k">if</span> ra != rb:
+                    parent[rb] = ra
+    <span class="k">return</span> len({find(i) <span class="k">for</span> i <span class="k">in</span> range(len(groups))})
+
+
+<span class="k">def</span> right_angle_edges(me):
+    <span class="s">&quot;&quot;&quot;Manifold edges whose two faces meet at 90 degrees, iron and timber.
+
+    Every box and ring in the piece is chamfered, and a chamfer turns a
+    90-degree edge into two shallower ones. An edge still at 90 is one a
+    bevel pass skipped: the razor edge that renders as a hard black line.
+    Copied from showcase/crate-stack (do not import across pieces).
+    &quot;&quot;&quot;</span>
+    counts = {WOOD_IDX: <span class="n">0</span>, METAL_IDX: <span class="n">0</span>}
+    bm = bmesh.new()
+    <span class="k">try</span>:
+        bm.from_mesh(me)
+        <span class="k">for</span> e <span class="k">in</span> bm.edges:
+            <span class="k">if</span> len(e.link_faces) != <span class="n">2</span>:
+                <span class="k">continue</span>
+            <span class="k">if</span> abs(e.calc_face_angle(<span class="n">0.0</span>) - math.pi / <span class="n">2.0</span>) &lt;= RIGHT_ANGLE_TOL:
+                idx = e.link_faces[<span class="n">0</span>].material_index
+                counts[idx] = counts.get(idx, <span class="n">0</span>) + <span class="n">1</span>
+    <span class="k">finally</span>:
+        bm.free()
+    <span class="k">return</span> counts
+
+
 <span class="k">def</span> min_mat_distance(me, ia, ib):
     <span class="s">&quot;&quot;&quot;Closest surface distance between two material islands via BVH.
 
@@ -1190,6 +1686,27 @@ <h2>Source</h2>
     <span class="k">return</span> collider
 
 
+<span class="k">def</span> texel_audit(mesh, img):
+    <span class="s">&quot;&quot;&quot;Smallest UV cell, in baked texels along its longer side.
+
+    Every face packs into its own UV cell, so a small image spreads a few
+    texels over each face and the render&#x27;s bilinear lookup reads the next
+    cell&#x27;s normals across the border. Copied from showcase/tavern-stool
+    (do not import across pieces).
+    &quot;&quot;&quot;</span>
+    uv = mesh.uv_layers.active
+    <span class="k">if</span> uv <span class="k">is</span> <span class="k">None</span> <span class="k">or</span> img <span class="k">is</span> <span class="k">None</span>:
+        <span class="k">return</span> <span class="n">0.0</span>
+    res = min(img.size[<span class="n">0</span>], img.size[<span class="n">1</span>])
+    data = uv.data
+    worst = <span class="n">1e9</span>
+    <span class="k">for</span> poly <span class="k">in</span> mesh.polygons:
+        us = [data[i].uv[<span class="n">0</span>] <span class="k">for</span> i <span class="k">in</span> poly.loop_indices]
+        vs = [data[i].uv[<span class="n">1</span>] <span class="k">for</span> i <span class="k">in</span> poly.loop_indices]
+        worst = min(worst, max(max(us) - min(us), max(vs) - min(vs)) * res)
+    <span class="k">return</span> worst
+
+
 <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>
@@ -1242,24 +1759,19 @@ <h2>Source</h2>
     )
 
 
+<span class="k">def</span> _no():
+    <span class="k">return</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">def</span> check(skip_decimate, lift_z=<span class="k">False</span>, flush_tyre=<span class="k">False</span>, sink_tyre=<span class="k">False</span>,
-          float_wheel=<span class="k">False</span>, skew_wheel=<span class="k">False</span>):
+          float_wheel=<span class="k">False</span>, skew_wheel=<span class="k">False</span>, short_props=<span class="k">False</span>,
+          wide_seams=<span class="k">False</span>, lift_bed_flag=<span class="k">False</span>, sharp_bar=<span class="k">False</span>,
+          low_bake=<span class="k">False</span>):
     bpy.ops.wm.read_factory_settings(use_empty=<span class="k">True</span>)
-    low = build_cart_mesh(<span class="s">&quot;CartLow&quot;</span>, bevel_offset=<span class="n">0.005</span>, bevel_segments=<span class="n">2</span>)
-    high = build_cart_mesh(<span class="s">&quot;CartHigh&quot;</span>, bevel_offset=<span class="n">0.005</span>, bevel_segments=<span class="n">4</span>)
-    wood = principled(
-        <span class="s">&quot;CartWood&quot;</span>, (<span class="n">0.42</span>, <span class="n">0.22</span>, <span class="n">0.08</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.58</span>,
-        noise_scale=<span class="n">7.0</span>, wear=(<span class="n">0.26</span>, <span class="n">0.12</span>, <span class="n">0.04</span>, <span class="n">1.0</span>),
-    )
-    <span class="c"># Wrought iron, not black plastic. At (0.13, 0.32) the tyre rendered as</span>
-    <span class="c"># a flat black band with no sheen — darker and glossier than every</span>
-    <span class="c"># sibling piece&#x27;s iron (hitching-post 0.16/0.48, wooden-ladder</span>
-    <span class="c"># 0.18/0.48). Raised to sit inside that calibration range, and the wear</span>
-    <span class="c"># colour lifted off near-black so the noise actually varies the surface.</span>
-    metal = principled(
-        <span class="s">&quot;CartIron&quot;</span>, (<span class="n">0.20</span>, <span class="n">0.195</span>, <span class="n">0.185</span>, <span class="n">1.0</span>), <span class="n">1.0</span>, <span class="n">0.50</span>,
-        noise_scale=<span class="n">5.0</span>, wear=(<span class="n">0.11</span>, <span class="n">0.105</span>, <span class="n">0.10</span>, <span class="n">1.0</span>),
-    )
+    flags = dict(sharp_bar=sharp_bar, wide_seams=wide_seams, short_props=short_props)
+    low = build_cart_mesh(<span class="s">&quot;CartLow&quot;</span>, <span class="n">0.005</span>, <span class="n">1</span>, **flags)
+    high = build_cart_mesh(<span class="s">&quot;CartHigh&quot;</span>, <span class="n">0.005</span>, <span class="n">3</span>, **flags)
+    wood, metal = cart_materials()
     assign_slots(low, wood, metal)
     assign_slots(high, wood, metal)
     <span class="k">if</span> lift_z:
@@ -1274,9 +1786,11 @@ <h2>Source</h2>
         move_one_wheel(low.data, (<span class="n">0.0</span>, <span class="n">0.0</span>, FLOAT_WHEEL_Z))
     <span class="k">if</span> skew_wheel:
         move_one_wheel(low.data, (<span class="n">0.0</span>, SKEW_WHEEL_Y, <span class="n">0.0</span>))
+    <span class="k">if</span> lift_bed_flag:
+        lift_bed(low.data, LIFT_BED)
 
     <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;cart 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>
+        <span class="k">return</span> (fail(<span class="s">&quot;cart mesh did not build&quot;</span>, <span class="n">3</span>),) + _no()
 
     base_tris = triangle_count(low.data)
     mats = [s <span class="k">for</span> s <span class="k">in</span> low.data.materials <span class="k">if</span> s <span class="k">is</span> <span class="k">not</span> <span class="k">None</span>]
@@ -1292,10 +1806,12 @@ <h2>Source</h2>
     size_y = bb[<span class="n">4</span>] - bb[<span class="n">1</span>]
     size_z = bb[<span class="n">5</span>] - bb[<span class="n">2</span>]
 
-    img, tex = setup_bake_image(low, wood)
+    img, tex = setup_bake_image(low, wood, LOW_BAKE_RES <span class="k">if</span> low_bake <span class="k">else</span> BAKE_RES)
     <span class="k">if</span> img <span class="k">is</span> <span class="k">None</span>:
-        <span class="k">return</span> fail(<span class="s">&quot;cart has no UV layer&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>
+        <span class="k">return</span> (fail(<span class="s">&quot;cart has no UV layer&quot;</span>, <span class="n">3</span>),) + _no()
     bake_result = bake_normal(high, low)
+    texel = texel_audit(low.data, img)
+    print(<span class="s">f&quot;</span><span class="s">measured bake_res=</span>{img.size[<span class="n">0</span>]}<span class="s"> texel_min=</span>{texel:<span class="s">.2f</span>}<span class="s">&quot;</span>)
 
     lod1 = make_lod(low, <span class="s">&quot;CartLOD1&quot;</span>, LOD1_TARGET, skip_decimate)
     lod2 = make_lod(low, <span class="s">&quot;CartLOD2&quot;</span>, LOD2_TARGET, skip_decimate)
@@ -1305,7 +1821,7 @@ <h2>Source</h2>
     r1 = lod1_tris / base_tris <span class="k">if</span> base_tris <span class="k">else</span> <span class="n">0.0</span>
     r2 = lod2_tris / base_tris <span class="k">if</span> base_tris <span class="k">else</span> <span class="n">0.0</span>
 
-    collider_src = build_cart_mesh(<span class="s">&quot;CartColSrc&quot;</span>, bevel_offset=<span class="n">0.0</span>, bevel_segments=<span class="n">1</span>)
+    collider_src = build_cart_mesh(<span class="s">&quot;CartColSrc&quot;</span>, <span class="n">0.0</span>, <span class="n">1</span>)
     collider = convex_hull_collider(collider_src, <span class="s">&quot;CartCollider&quot;</span>)
     bpy.data.objects.remove(collider_src, do_unlink=<span class="k">True</span>)
     col_tris = triangle_count(collider.data)
@@ -1357,16 +1873,14 @@ <h2>Source</h2>
     groups = shell_groups(low.data)
     zfight = coplanar_zfight_pairs(low.data, groups)
     wheels = wheel_shells(low.data, groups)
-    support_zmins = {}
+    supports, n_legs = support_audit(low.data, groups, wheels)
     seats = []
     <span class="k">for</span> side, parts <span class="k">in</span> sorted(wheels.items()):
-        tb = shell_box(low.data, groups[parts[<span class="s">&quot;tyre&quot;</span>]])
-        support_zmins[<span class="s">&quot;+Y&quot;</span> <span class="k">if</span> side &gt; <span class="n">0</span> <span class="k">else</span> <span class="s">&quot;-Y&quot;</span>] = round(tb[<span class="s">&quot;zmin&quot;</span>], <span class="n">6</span>)
         depths, _ = tyre_seat_depths(
             low.data, groups, parts[<span class="s">&quot;rim&quot;</span>], parts[<span class="s">&quot;tyre&quot;</span>], WHEEL_SEGMENTS
         )
         seats.extend(depths)
-    support_worst = max((abs(z) <span class="k">for</span> z <span class="k">in</span> support_zmins.values()), default=<span class="n">1e9</span>)
+    support_worst = max((abs(z) <span class="k">for</span> z <span class="k">in</span> supports.values()), default=<span class="n">1e9</span>)
     seat_min = min(seats) <span class="k">if</span> seats <span class="k">else</span> -<span class="n">1.0</span>
     seat_max = max(seats) <span class="k">if</span> seats <span class="k">else</span> <span class="n">1e9</span>
     seat_n = len(seats)
@@ -1389,81 +1903,74 @@ <h2>Source</h2>
             abs(a[<span class="n">0</span>] - b2[<span class="n">0</span>]), abs(a[<span class="n">1</span>] + b2[<span class="n">1</span>]), abs(a[<span class="n">2</span>] - b2[<span class="n">2</span>]),
             abs(a[<span class="n">3</span>] - b2[<span class="n">3</span>]), abs(a[<span class="n">4</span>] - b2[<span class="n">4</span>]),
         )
+    n_left, n_right, seams = wall_board_audit(low.data, groups)
+    seam_lo = min(seams) <span class="k">if</span> seams <span class="k">else</span> -<span class="n">1.0</span>
+    seam_hi = max(seams) <span class="k">if</span> seams <span class="k">else</span> <span class="n">1e9</span>
+    components = contact_components(low.data, groups)
+    right_angles = right_angle_edges(low.data)
+    n_right_angles = sum(right_angles.values())
     print(
         <span class="s">f&quot;</span><span class="s">measured zfight_pairs=</span>{zfight}<span class="s"> shells=</span>{len(groups)}<span class="s"> </span><span class="s">&quot;</span>
-        <span class="s">f&quot;</span><span class="s">support_zmin=</span>{support_zmins}<span class="s"> </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">supports=</span>{ {k: round(v, <span class="n">6</span>) <span class="k">for</span> k, v <span class="k">in</span> supports.items()} }<span class="s"> legs=</span>{n_legs}<span class="s"> </span><span class="s">&quot;</span>
         <span class="s">f&quot;</span><span class="s">tyre_seat=[</span>{seat_min:<span class="s">.5f</span>}<span class="s">,</span>{seat_max:<span class="s">.5f</span>}<span class="s">] over </span>{seat_n}<span class="s"> stations </span><span class="s">&quot;</span>
         <span class="s">f&quot;</span><span class="s">wheel_mirror=</span>{wheel_mirror*<span class="n">1000</span>:<span class="s">.5f</span>}<span class="s">mm</span><span class="s">&quot;</span>
     )
+    print(
+        <span class="s">f&quot;</span><span class="s">measured wall_boards=(</span>{n_left}<span class="s">,</span>{n_right}<span class="s">) </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">seams=[</span>{seam_lo:<span class="s">.5f</span>}<span class="s">,</span>{seam_hi:<span class="s">.5f</span>}<span class="s">] components=</span>{components}<span class="s"> </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">right_angle_edges=</span>{right_angles}<span class="s">&quot;</span>
+    )
 
     <span class="k">if</span> len(wheels) != <span class="n">2</span> <span class="k">or</span> any(len(p) != <span class="n">2</span> <span class="k">for</span> p <span class="k">in</span> wheels.values()):
-        <span class="k">return</span> fail(
-            <span class="s">f&quot;</span><span class="s">expected 2 wheels of (rim, tyre) shells, found </span>{wheels}<span class="s">&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>
+        <span class="k">return</span> (fail(<span class="s">f&quot;</span><span class="s">expected 2 wheels of (rim, tyre) shells, found </span>{wheels}<span class="s">&quot;</span>, <span class="n">3</span>),) + _no()
     <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>,
-            <span class="n">4</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> (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>, <span class="n">4</span>,
+        ),) + _no()
     <span class="k">if</span> nmat != MATERIAL_COUNT <span class="k">or</span> distinct_mats != MATERIAL_COUNT:
-        <span class="k">return</span> fail(
-            <span class="s">f&quot;</span><span class="s">material slots </span>{nmat}<span class="s"> distinct </span>{distinct_mats}<span class="s"> != </span>{MATERIAL_COUNT}<span class="s">&quot;</span>,
-            <span class="n">5</span>,
-        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+        <span class="k">return</span> (fail(
+            <span class="s">f&quot;</span><span class="s">material slots </span>{nmat}<span class="s"> distinct </span>{distinct_mats}<span class="s"> != </span>{MATERIAL_COUNT}<span class="s">&quot;</span>, <span class="n">5</span>,
+        ),) + _no()
     <span class="k">if</span> idx_counts.get(METAL_IDX, <span class="n">0</span>) &lt; METAL_FACES_MIN:
-        <span class="k">return</span> fail(
-            <span class="s">f&quot;</span><span class="s">metal faces </span>{idx_counts.get(METAL_IDX, <span class="n">0</span>)}<span class="s"> &lt; </span>{METAL_FACES_MIN}<span class="s">&quot;</span>,
-            <span class="n">5</span>,
-        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+        <span class="k">return</span> (fail(
+            <span class="s">f&quot;</span><span class="s">metal faces </span>{idx_counts.get(METAL_IDX, <span class="n">0</span>)}<span class="s"> &lt; </span>{METAL_FACES_MIN}<span class="s">&quot;</span>, <span class="n">5</span>,
+        ),) + _no()
     <span class="k">if</span> idx_counts.get(WOOD_IDX, <span class="n">0</span>) &lt; WOOD_FACES_MIN:
-        <span class="k">return</span> fail(
-            <span class="s">f&quot;</span><span class="s">wood faces </span>{idx_counts.get(WOOD_IDX, <span class="n">0</span>)}<span class="s"> &lt; </span>{WOOD_FACES_MIN}<span class="s">&quot;</span>,
-            <span class="n">5</span>,
-        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+        <span class="k">return</span> (fail(
+            <span class="s">f&quot;</span><span class="s">wood faces </span>{idx_counts.get(WOOD_IDX, <span class="n">0</span>)}<span class="s"> &lt; </span>{WOOD_FACES_MIN}<span class="s">&quot;</span>, <span class="n">5</span>,
+        ),) + _no()
     <span class="k">if</span> u0 &lt; -UV_EPS <span class="k">or</span> v0 &lt; -UV_EPS <span class="k">or</span> u1 &gt; <span class="n">1.0</span> + UV_EPS <span class="k">or</span> v1 &gt; <span class="n">1.0</span> + UV_EPS:
-        <span class="k">return</span> fail(
-            <span class="s">f&quot;</span><span class="s">UVs outside 0..1: (</span>{u0:<span class="s">.4f</span>}<span class="s">,</span>{v0:<span class="s">.4f</span>}<span class="s">)-(</span>{u1:<span class="s">.4f</span>}<span class="s">,</span>{v1:<span class="s">.4f</span>}<span class="s">)</span><span class="s">&quot;</span>,
-            <span class="n">6</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> (fail(
+            <span class="s">f&quot;</span><span class="s">UVs outside 0..1: (</span>{u0:<span class="s">.4f</span>}<span class="s">,</span>{v0:<span class="s">.4f</span>}<span class="s">)-(</span>{u1:<span class="s">.4f</span>}<span class="s">,</span>{v1:<span class="s">.4f</span>}<span class="s">)</span><span class="s">&quot;</span>, <span class="n">6</span>,
+        ),) + _no()
     <span class="k">if</span> overlap &gt; UV_OVERLAP_MAX:
-        <span class="k">return</span> fail(
-            <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">return</span> (fail(<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>),) + _no()
     <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
         <span class="k">or</span> abs(size_z - OUTER_SIZE[<span class="n">2</span>]) &gt; BBOX_TOL
     ):
-        <span class="k">return</span> fail(
-            <span class="s">f&quot;</span><span class="s">bbox (</span>{size_x:<span class="s">.4f</span>}<span class="s">,</span>{size_y:<span class="s">.4f</span>}<span class="s">,</span>{size_z:<span class="s">.4f</span>}<span class="s">) </span><span class="s">&quot;</span>
-            <span class="s">f&quot;</span><span class="s">off outer </span>{OUTER_SIZE}<span class="s">&quot;</span>,
-            <span class="n">8</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> (fail(
+            <span class="s">f&quot;</span><span class="s">bbox (</span>{size_x:<span class="s">.4f</span>}<span class="s">,</span>{size_y:<span class="s">.4f</span>}<span class="s">,</span>{size_z:<span class="s">.4f</span>}<span class="s">) off outer </span>{OUTER_SIZE}<span class="s">&quot;</span>, <span class="n">8</span>,
+        ),) + _no()
     <span class="k">if</span> <span class="k">not</span> (LOD1_RATIO_MIN &lt;= r1 &lt;= LOD1_RATIO_MAX):
-        <span class="k">return</span> fail(
+        <span class="k">return</span> (fail(
             <span class="s">f&quot;</span><span class="s">LOD1 ratio </span>{r1:<span class="s">.4f</span>}<span class="s"> not in [</span>{LOD1_RATIO_MIN}<span class="s">, </span>{LOD1_RATIO_MAX}<span class="s">] </span><span class="s">&quot;</span>
             <span class="s">&quot;(--skip-decimate is the designed fail)&quot;</span>,
             <span class="n">9</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>
+        ),) + _no()
     <span class="k">if</span> <span class="k">not</span> (LOD2_RATIO_MIN &lt;= r2 &lt;= LOD2_RATIO_MAX):
-        <span class="k">return</span> fail(
-            <span class="s">f&quot;</span><span class="s">LOD2 ratio </span>{r2:<span class="s">.4f</span>}<span class="s"> not in [</span>{LOD2_RATIO_MIN}<span class="s">, </span>{LOD2_RATIO_MAX}<span class="s">]</span><span class="s">&quot;</span>,
-            <span class="n">9</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> (fail(
+            <span class="s">f&quot;</span><span class="s">LOD2 ratio </span>{r2:<span class="s">.4f</span>}<span class="s"> not in [</span>{LOD2_RATIO_MIN}<span class="s">, </span>{LOD2_RATIO_MAX}<span class="s">]</span><span class="s">&quot;</span>, <span class="n">9</span>,
+        ),) + _no()
     <span class="k">if</span> col_tris &gt; COLLIDER_TRIS_MAX:
-        <span class="k">return</span> fail(
-            <span class="s">f&quot;</span><span class="s">collider tris </span>{col_tris}<span class="s"> &gt; </span>{COLLIDER_TRIS_MAX}<span class="s">&quot;</span>,
-            <span class="n">11</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> (fail(<span class="s">f&quot;</span><span class="s">collider tris </span>{col_tris}<span class="s"> &gt; </span>{COLLIDER_TRIS_MAX}<span class="s">&quot;</span>, <span class="n">11</span>),) + _no()
     <span class="k">if</span> bake_result != {<span class="s">&quot;FINISHED&quot;</span>} <span class="k">or</span> <span class="k">not</span> img.has_data:
-        <span class="k">return</span> fail(
-            <span class="s">f&quot;</span><span class="s">bake failed result=</span>{bake_result}<span class="s"> has_data=</span>{img.has_data}<span class="s">&quot;</span>,
-            <span class="n">12</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> (fail(
+            <span class="s">f&quot;</span><span class="s">bake failed result=</span>{bake_result}<span class="s"> has_data=</span>{img.has_data}<span class="s">&quot;</span>, <span class="n">12</span>,
+        ),) + _no()
     <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">return</span> (fail(<span class="s">&quot;export file missing or empty&quot;</span>, <span class="n">13</span>),) + _no()
     <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>]
@@ -1472,55 +1979,85 @@ <h2>Source</h2>
         <span class="k">or</span> hyg[<span class="s">&quot;doubles&quot;</span>]
         <span class="k">or</span> hyg[<span class="s">&quot;ngons&quot;</span>]
     ):
-        <span class="k">return</span> fail(
+        <span class="k">return</span> (fail(
             <span class="s">f&quot;</span><span class="s">hygiene loose_v=</span>{hyg[<span class="s">&#x27;loose_v&#x27;</span>]}<span class="s"> loose_e=</span>{hyg[<span class="s">&#x27;loose_e&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
             <span class="s">f&quot;</span><span class="s">nonman=</span>{hyg[<span class="s">&#x27;nonman&#x27;</span>]}<span class="s"> zero_area=</span>{hyg[<span class="s">&#x27;zero_area&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
             <span class="s">f&quot;</span><span class="s">doubles=</span>{hyg[<span class="s">&#x27;doubles&#x27;</span>]}<span class="s"> ngons=</span>{hyg[<span class="s">&#x27;ngons&#x27;</span>]}<span class="s">&quot;</span>,
             <span class="n">15</span>,
-        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+        ),) + _no()
     <span class="k">if</span> zfight &gt; ZFIGHT_PAIRS_MAX:
-        <span class="k">return</span> fail(
+        <span class="k">return</span> (fail(
             <span class="s">f&quot;</span><span class="s">coplanar cross-shell face pairs </span>{zfight}<span class="s"> &gt; </span>{ZFIGHT_PAIRS_MAX}<span class="s"> </span><span class="s">&quot;</span>
             <span class="s">&quot;(--flush-tyre is the designed fail: a tyre whose inner radius &quot;</span>
             <span class="s">&quot;equals the felloe&#x27;s outer radius puts both on one plane)&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>
+        ),) + _no()
     <span class="k">if</span> abs(bb[<span class="n">2</span>]) &gt; ZMIN_EPS:
-        <span class="k">return</span> fail(
+        <span class="k">return</span> (fail(
             <span class="s">f&quot;</span><span class="s">zmin </span>{bb[<span class="n">2</span>]:<span class="s">.6f</span>}<span class="s"> not within </span>{ZMIN_EPS}<span class="s"> of 0 </span><span class="s">&quot;</span>
             <span class="s">&quot;(--lift-z is the designed fail)&quot;</span>,
             <span class="n">16</span>,
-        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
-    <span class="k">if</span> support_worst &gt; SUPPORT_ZMIN_EPS:
-        <span class="k">return</span> fail(
-            <span class="s">f&quot;</span><span class="s">named support zmin </span>{support_worst:<span class="s">.6f</span>}<span class="s"> &gt; </span>{SUPPORT_ZMIN_EPS}<span class="s"> </span><span class="s">&quot;</span>
-            <span class="s">f&quot;</span><span class="s">per-tyre zmin=</span>{support_zmins}<span class="s"> </span><span class="s">&quot;</span>
-            <span class="s">&quot;(--float-wheel is the designed fail: one tyre off the floor &quot;</span>
-            <span class="s">&quot;while the other still grounds the AABB)&quot;</span>,
+        ),) + _no()
+    <span class="k">if</span> n_legs != N_LEGS <span class="k">or</span> support_worst &gt; SUPPORT_ZMIN_EPS:
+        <span class="k">return</span> (fail(
+            <span class="s">f&quot;</span><span class="s">named supports </span>{supports}<span class="s"> legs=</span>{n_legs}<span class="s">: worst zmin </span><span class="s">&quot;</span>
+            <span class="s">f&quot;</span>{support_worst:<span class="s">.6f</span>}<span class="s"> &gt; </span>{SUPPORT_ZMIN_EPS}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">&quot;(--float-wheel and --short-props are the designed fails: one &quot;</span>
+            <span class="s">&quot;support off the floor while the rest still ground the AABB)&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>
+        ),) + _no()
     <span class="k">if</span> gap_mw &gt; GAP_MAX:
-        <span class="k">return</span> fail(
+        <span class="k">return</span> (fail(
             <span class="s">f&quot;</span><span class="s">metal-wood gap </span>{gap_mw:<span class="s">.5f</span>}<span class="s"> &gt; </span>{GAP_MAX}<span class="s"> </span><span class="s">&quot;</span>
-            <span class="s">&quot;(tyres, hubs, straps, and plates must touch the wood they mount to)&quot;</span>,
+            <span class="s">&quot;(tyres, bands, washers and straps must touch the wood they mount to)&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>
+        ),) + _no()
+    <span class="k">if</span> (n_left, n_right) != (WALL_BOARDS, WALL_BOARDS) <span class="k">or</span> <span class="k">not</span> (
+        WALL_SEAM_MIN &lt;= seam_lo <span class="k">and</span> seam_hi &lt;= WALL_SEAM_MAX
+    ):
+        <span class="k">return</span> (fail(
+            <span class="s">f&quot;</span><span class="s">side-wall boards (</span>{n_left}<span class="s">,</span>{n_right}<span class="s">) != </span>{WALL_BOARDS}<span class="s"> per side or </span><span class="s">&quot;</span>
+            <span class="s">f&quot;</span><span class="s">seams [</span>{seam_lo:<span class="s">.5f</span>}<span class="s">,</span>{seam_hi:<span class="s">.5f</span>}<span class="s">] outside </span><span class="s">&quot;</span>
+            <span class="s">f&quot;</span><span class="s">[</span>{WALL_SEAM_MIN}<span class="s">, </span>{WALL_SEAM_MAX}<span class="s">] </span><span class="s">&quot;</span>
+            <span class="s">&quot;(--wide-seams is the designed fail)&quot;</span>,
+            <span class="n">17</span>,
+        ),) + _no()
     <span class="k">if</span> seat_min &lt; TYRE_SEAT_MIN <span class="k">or</span> seat_max &gt; TYRE_SEAT_MAX:
-        <span class="k">return</span> fail(
+        <span class="k">return</span> (fail(
             <span class="s">f&quot;</span><span class="s">tyre seat depth band [</span>{seat_min:<span class="s">.5f</span>}<span class="s">, </span>{seat_max:<span class="s">.5f</span>}<span class="s">] outside </span><span class="s">&quot;</span>
             <span class="s">f&quot;</span><span class="s">[</span>{TYRE_SEAT_MIN}<span class="s">, </span>{TYRE_SEAT_MAX}<span class="s">] over </span>{seat_n}<span class="s"> stations </span><span class="s">&quot;</span>
             <span class="s">&quot;(--sink-tyre is the designed fail: the hoop swallowed by the &quot;</span>
             <span class="s">&quot;felloe reads as one body, not a tyre)&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>
+        ),) + _no()
+    <span class="k">if</span> components != CONTACT_COMPONENTS:
+        <span class="k">return</span> (fail(
+            <span class="s">f&quot;</span><span class="s">shell contact graph has </span>{components}<span class="s"> components, expected </span><span class="s">&quot;</span>
+            <span class="s">f&quot;</span>{CONTACT_COMPONENTS}<span class="s"> (--lift-bed is the designed fail: the box </span><span class="s">&quot;</span>
+            <span class="s">&quot;raised off its rails is joined to nothing below it)&quot;</span>,
+            <span class="n">18</span>,
+        ),) + _no()
     <span class="k">if</span> wheel_mirror &gt; WHEEL_MIRROR_EPS:
-        <span class="k">return</span> fail(
+        <span class="k">return</span> (fail(
             <span class="s">f&quot;</span><span class="s">wheel mirror deviation </span>{wheel_mirror*<span class="n">1000</span>:<span class="s">.4f</span>}<span class="s"> mm &gt; </span><span class="s">&quot;</span>
             <span class="s">f&quot;</span>{WHEEL_MIRROR_EPS*<span class="n">1000</span>:<span class="s">.4f</span>}<span class="s"> mm </span><span class="s">&quot;</span>
             <span class="s">&quot;(--skew-wheel is the designed fail: the two wheels are one part &quot;</span>
             <span class="s">&quot;reflected in Y and must sit at matched X and Z)&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>
+        ),) + _no()
+    <span class="k">if</span> n_right_angles &gt; RIGHT_ANGLE_MAX:
+        <span class="k">return</span> (fail(
+            <span class="s">f&quot;</span><span class="s">right-angle edges </span>{right_angles}<span class="s"> &gt; </span>{RIGHT_ANGLE_MAX}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">&quot;(--sharp-bar is the designed fail: the pull bar left unchamfered)&quot;</span>,
+            <span class="n">20</span>,
+        ),) + _no()
+    <span class="k">if</span> texel &lt; TEXEL_MIN:
+        <span class="k">return</span> (fail(
+            <span class="s">f&quot;</span><span class="s">bake texel density </span>{texel:<span class="s">.2f</span>}<span class="s"> px per UV cell &lt; </span>{TEXEL_MIN}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">&quot;(--low-bake is the designed fail: a 256 px bake smears each &quot;</span>
+            <span class="s">&quot;face&#x27;s normals into its neighbours&#x27;)&quot;</span>,
+            <span class="n">21</span>,
+        ),) + _no()
     <span class="k">return</span> <span class="n">0</span>, low, high, wood, tex, collider
 
 
@@ -1547,7 +2084,7 @@ <h2>Source</h2>
     floor_me = bpy.data.meshes.new(<span class="s">&quot;Floor&quot;</span>)
     bm = bmesh.new()
     <span class="k">try</span>:
-        bmesh.ops.create_grid(bm, x_segments=<span class="n">1</span>, y_segments=<span class="n">1</span>, size=<span class="n">14.0</span>)
+        bmesh.ops.create_grid(bm, x_segments=<span class="n">1</span>, y_segments=<span class="n">1</span>, size=<span class="n">60.0</span>)
         bm.to_mesh(floor_me)
     <span class="k">finally</span>:
         bm.free()
@@ -1667,6 +2204,36 @@ <h2>Source</h2>
         help=<span class="s">&quot;falsification: push one wheel out along the track so the &quot;</span>
              <span class="s">&quot;wheel-mirror budget fails&quot;</span>,
     )
+    p.add_argument(
+        <span class="s">&quot;--short-props&quot;</span>,
+        action=<span class="s">&quot;store_true&quot;</span>,
+        help=<span class="s">&quot;falsification: stop both prop legs 3 mm above the floor while &quot;</span>
+             <span class="s">&quot;the tyres still ground the AABB, so the named-support budget fails&quot;</span>,
+    )
+    p.add_argument(
+        <span class="s">&quot;--wide-seams&quot;</span>,
+        action=<span class="s">&quot;store_true&quot;</span>,
+        help=<span class="s">&quot;falsification: open the wall-board seams to 10 mm (same &quot;</span>
+             <span class="s">&quot;triangles), so the board-seam budget fails&quot;</span>,
+    )
+    p.add_argument(
+        <span class="s">&quot;--lift-bed&quot;</span>,
+        action=<span class="s">&quot;store_true&quot;</span>,
+        help=<span class="s">&quot;falsification: raise the box off its rails, so the contact &quot;</span>
+             <span class="s">&quot;graph splits and the one-assembly budget fails&quot;</span>,
+    )
+    p.add_argument(
+        <span class="s">&quot;--sharp-bar&quot;</span>,
+        action=<span class="s">&quot;store_true&quot;</span>,
+        help=<span class="s">&quot;falsification: leave the pull bar&#x27;s rims unchamfered, so the &quot;</span>
+             <span class="s">&quot;edge-treatment budget fails&quot;</span>,
+    )
+    p.add_argument(
+        <span class="s">&quot;--low-bake&quot;</span>,
+        action=<span class="s">&quot;store_true&quot;</span>,
+        help=<span class="s">&quot;falsification: bake the normal map at 256 px, so the &quot;</span>
+             <span class="s">&quot;texel-density budget fails&quot;</span>,
+    )
     args = p.parse_args(argv)
 
     code, low, _high, wood, tex, _col = check(
@@ -1676,6 +2243,11 @@ <h2>Source</h2>
         sink_tyre=args.sink_tyre,
         float_wheel=args.float_wheel,
         skew_wheel=args.skew_wheel,
+        short_props=args.short_props,
+        wide_seams=args.wide_seams,
+        lift_bed_flag=args.lift_bed,
+        sharp_bar=args.sharp_bar,
+        low_bake=args.low_bake,
     )
     <span class="k">if</span> code:
         <span class="k">return</span> code
@@ -1700,7 +2272,7 @@ <h2>Source</h2>
   </main>
   <dialog class="lightbox" id="lightbox" aria-label="Full-size render">
     <button class="lightbox-close" type="button" autofocus>Close</button>
-    <img src="../assets/cart-hero.webp" alt="A two-wheeled wooden cart with spoked wheels, an open box bed and long shafts resting on the floor." />
+    <img src="../assets/cart-hero.webp" alt="A wooden handcart with a planked box bed and iron corner straps on two spoked wheels, standing level on two prop legs with its shafts joined by a pull bar." />
   </dialog>
   <footer>
     <div class="statusbar">
diff --git a/docs/gallery/contact-sheets/attribute-domain-shear-contact-sheet.webp b/docs/gallery/contact-sheets/attribute-domain-shear-contact-sheet.webp
index 3cec3187..b67f8fa9 100644
Binary files a/docs/gallery/contact-sheets/attribute-domain-shear-contact-sheet.webp and b/docs/gallery/contact-sheets/attribute-domain-shear-contact-sheet.webp differ
diff --git a/docs/gallery/contact-sheets/cart-contact-sheet.webp b/docs/gallery/contact-sheets/cart-contact-sheet.webp
index c95d455d..b304e589 100644
Binary files a/docs/gallery/contact-sheets/cart-contact-sheet.webp and b/docs/gallery/contact-sheets/cart-contact-sheet.webp differ
diff --git a/docs/gallery/contact-sheets/grindstone-contact-sheet.webp b/docs/gallery/contact-sheets/grindstone-contact-sheet.webp
index 9e4c8dfc..7e03c7bd 100644
Binary files a/docs/gallery/contact-sheets/grindstone-contact-sheet.webp and b/docs/gallery/contact-sheets/grindstone-contact-sheet.webp differ
diff --git a/docs/gallery/grindstone/index.html b/docs/gallery/grindstone/index.html
index 0bd6d448..ff6296ad 100644
--- a/docs/gallery/grindstone/index.html
+++ b/docs/gallery/grindstone/index.html
@@ -16,13 +16,13 @@
   <meta property="og:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/grindstone-hero.webp" />
   <meta property="og:image:width" content="1280" />
   <meta property="og:image:height" content="720" />
-  <meta property="og:image:alt" content="A round grey grindstone with a crank handle, mounted in a wooden A-frame trestle." />
+  <meta property="og:image:alt" content="A sandstone grindstone wheel with an iron crank, turning in a chamfered timber A-frame over an open trough, its sills capped by iron shoes." />
   <meta property="og:site_name" content="Blender Developer Tools" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="grindstone — Showcase — Blender Developer Tools" />
   <meta name="twitter:description" content="A procedural grindstone on a timber trestle 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/grindstone-hero.webp" />
-  <meta name="twitter:image:alt" content="A round grey grindstone with a crank handle, mounted in a wooden A-frame trestle." />
+  <meta name="twitter:image:alt" content="A sandstone grindstone wheel with an iron crank, turning in a chamfered timber A-frame over an open trough, its sills capped by iron shoes." />
   <style>
     /* fonts are deployed by the landing build (docs/fonts/) */
     @font-face { font-family: 'Barlow Condensed'; font-weight: 600; font-display: swap;
@@ -268,47 +268,54 @@ <h1>grindstone</h1>
     <p>A procedural grindstone on a timber trestle 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="View full size: A round grey grindstone with a crank handle, mounted in a wooden A-frame trestle.">
-      <img src="../assets/grindstone-hero.webp" alt="A round grey grindstone with a crank handle, mounted in a wooden A-frame trestle." width="1280" height="720" />
+    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: A sandstone grindstone wheel with an iron crank, turning in a chamfered timber A-frame over an open trough, its sills capped by iron shoes.">
+      <img src="../assets/grindstone-hero.webp" alt="A sandstone grindstone wheel with an iron crank, turning in a chamfered timber A-frame over an open trough, its sills capped by iron shoes." width="1280" height="720" />
     </button>
     <p class="zoom-hint">Rendered headless by the showcase piece itself — click to zoom.</p>
-    <div class="callout"><span class="tag">witnesses</span> Recomputed: 928 tris, three materials with 216 wood / 160 stone / 180 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.710×0.419×0.610 m, zmin 0, hygiene 0, four shoes planted, trough seated in the sills, stone dip 26 mm, LOD ratios in band (5.2 COLLAPSE leaner on LOD2), convex collider 198 tris, non-empty glTF. --skip-decimate exits 9 on LOD1; --stray-vert exits 15 on hygiene; --lift-z / --short-legs exit 16 on grounded; --float-crank / --float-legs exit 17 on joint fit; --no-dip / --narrow-trough exit 18 on seat.</div>
+    <div class="callout"><span class="tag">witnesses</span> Recomputed: 1668 tris, three materials with 400 wood / 240 stone / 364 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.722×0.419×0.610 m, zmin 0, hygiene 0 including zero coplanar cross-shell pairs, four shoes planted, trough seated in the sills and biting both stretchers 4 mm, stone dip 24 mm, no unchamfered right-angle edge, 29.44 bake texels per UV cell, LOD ratios in band, convex collider 304 tris, non-empty glTF. --skip-decimate exits 9 on LOD1; --stray-vert / --flush-shoes exit 15 on hygiene; --lift-z / --short-legs exit 16 on grounded; --float-crank / --float-legs exit 17 on joint fit; --no-dip / --narrow-trough / --low-stretchers exit 18 on seat; --sharp-handle exits 20 on edge treatment; --low-bake exits 21 on texel density.</div>
     <div class="runline">
       <pre id="runCmd">blender --background --python showcase/grindstone/grindstone.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 grindstone (sandstone wheel, timber A-frame trestle, iron shoes/axle/hubs/crank, open water trough) then the shipped pipeline: unique-cell UVs, Cycles high-to-low normal bake, LOD chain, convex collider, Unity glTF export.</p>
-<p>The A-frame is a king post with diagonals tenoning into a fatter sill, not two sticks meeting at a point. The trough is one manifold basin seated into those sills. Iron shoes bury a short wood tenon so the angled leg end-cap cannot pierce Z=0.</p>
+<p>A showcase piece, not an example. A procedural grindstone: a sandstone wheel, a timber A-frame trestle, iron shoes, axle, hubs and crank, and an open trough. The piece then runs the shipped pipeline: unique-cell UVs, a Cycles high-to-low normal bake, an LOD chain, a convex collider, and a Unity glTF export.</p>
+<p>Each A-frame is a king post with two diagonals tenoned 12 mm into its faces and into a fatter sill. It is not two sticks meeting at a point. The sills stand in iron shoes, cups one 6 mm reveal proud of the sill on every side. The trough is one manifold basin seated into the sills and carried on two end stretchers, which it bites by 4 mm. Every timber and iron edge is chamfered. The stone is 48 smooth segments with hard chamfer rings, in a mottled sandstone material. Stated size is a 0.50 m × 0.095 m stone in a 0.72 × 0.42 × 0.61 m frame.</p>
 <p>It asserts <strong>budget conformance</strong> of the generated result. It does not witness an API contract. &quot;It rendered without error&quot; is not a check.</p>
 <p><strong>Composes</strong> skills <code>mesh-editing-and-bmesh</code>, <code>bake-high-to-low</code>, <code>depsgraph-and-evaluated-data</code>, <code>engine-export-presets</code>, and snippets <code>bake_normal_high_to_low.py</code>, <code>setup_bake_target_image.py</code>, <code>lod_chain.py</code> / <code>decimate_to_budget.py</code>, <code>convex_hull_collider.py</code>, <code>export_preset_unity.py</code> (helpers copied, not imported as a package).</p>
 <h2>Budgets</h2>
 <p>Declared as named constants; every gate <strong>recomputes</strong> from the mesh, materials, UVs, evaluated LOD, collider, or export file.</p>
-<div class="table-wrap"><table><thead><tr><th scope="col">Axis</th><th scope="col">Declared</th><th scope="col">Measured (4.5.11 / 5.1.2 / 5.2.1)</th></tr></thead><tbody><tr><td>Base triangles</td><td>700–1000</td><td>928 / 928 / 928</td></tr><tr><td>LOD1 ratio</td><td>0.32–0.62 of base</td><td>0.5000 / 0.5000 / 0.5000</td></tr><tr><td>LOD2 ratio</td><td>0.10–0.35 of base</td><td>0.2198 / 0.2198 / 0.1897</td></tr><tr><td>Materials</td><td>exactly 3 distinct; ≥80 wood, stone, metal faces</td><td>3 slots; 216 / 160 / 180</td></tr><tr><td>UVs</td><td>in <code>0..1</code>, AABB overlap ≤ 1e-5</td><td>in range, overlap 0</td></tr><tr><td>Outer AABB</td><td>(0.710, 0.419, 0.610) m ± 0.015</td><td>(0.7100, 0.4185, 0.6100), zmin 0</td></tr><tr><td>Collider tris</td><td>≤ 240</td><td>198</td></tr><tr><td>Export</td><td>written, size &gt; 0</td><td>89316 / 89316 / 89312 bytes</td></tr></tbody></table></div>
+<div class="table-wrap"><table><thead><tr><th scope="col">Axis</th><th scope="col">Declared</th><th scope="col">Measured (4.5.11 / 5.1.2 / 5.2.1)</th></tr></thead><tbody><tr><td>Base triangles</td><td>1560–1780</td><td>1668 / 1668 / 1668</td></tr><tr><td>LOD1 ratio</td><td>0.32–0.62 of base</td><td>0.5000 / 0.5000 / 0.5000</td></tr><tr><td>LOD2 ratio</td><td>0.10–0.35 of base</td><td>0.2194 / 0.2194 / 0.2194</td></tr><tr><td>Materials</td><td>exactly 3 distinct; ≥ 280 wood, ≥ 190 stone, ≥ 260 metal faces</td><td>3 slots; 400 / 240 / 364</td></tr><tr><td>UVs</td><td>in <code>0..1</code>, AABB overlap ≤ 1e-5</td><td>in range, overlap 0</td></tr><tr><td>Outer AABB</td><td>(0.722, 0.419, 0.610) m ± 0.015</td><td>(0.7220, 0.4185, 0.6100), zmin 0</td></tr><tr><td>Collider tris</td><td>≤ 320</td><td>304</td></tr><tr><td>Bake texels</td><td>smallest UV cell ≥ 12 px at the baked resolution</td><td>29.44 px at 1024 px</td></tr><tr><td>Export</td><td>written, size &gt; 0</td><td>152272 / 152272 / 152260 bytes</td></tr></tbody></table></div>
+<p>The collider ceiling moved from 240 to 320 with the stone. 48 segments put more of its rim on the hull (198 → 304 triangles).</p>
 <h3>Hygiene</h3>
 <p>Recomputed from the generated mesh, not asserted about the script.</p>
-<div class="table-wrap"><table><thead><tr><th scope="col">Axis</th><th scope="col">Declared</th><th scope="col">Measured (all three)</th></tr></thead><tbody><tr><td>Non-manifold edges</td><td>0</td><td>0</td></tr><tr><td>Loose verts / edges</td><td>0 / 0</td><td>0 / 0</td></tr><tr><td>Doubles merged at 1e-5</td><td>0</td><td>0</td></tr><tr><td>Zero-area faces</td><td>0</td><td>0</td></tr><tr><td>N-gons</td><td>0</td><td>0</td></tr><tr><td>Coplanar disjoint face pairs</td><td>0</td><td>0</td></tr><tr><td>Grounded: <code>zmin</code></td><td>within 1e-4 of 0</td><td>0.0000</td></tr><tr><td>Named supports: 4 shoes</td><td>each <code>zmin</code> ≤ 1e-3</td><td>4, shoe_z 0.00000</td></tr><tr><td>Stone size</td><td>0.500 m dia × 0.095 m thick ± 0.02 / ± 0.015</td><td>0.5000 × 0.0950</td></tr></tbody></table></div>
+<div class="table-wrap"><table><thead><tr><th scope="col">Axis</th><th scope="col">Declared</th><th scope="col">Measured (all three)</th></tr></thead><tbody><tr><td>Non-manifold edges</td><td>0</td><td>0</td></tr><tr><td>Loose verts / edges</td><td>0 / 0</td><td>0 / 0</td></tr><tr><td>Doubles merged at 1e-5</td><td>0</td><td>0</td></tr><tr><td>Zero-area faces</td><td>0</td><td>0</td></tr><tr><td>N-gons</td><td>0</td><td>0</td></tr><tr><td>Coplanar cross-shell face pairs</td><td>0</td><td>0</td></tr><tr><td>Grounded: <code>zmin</code></td><td>within 1e-4 of 0</td><td>0.0000</td></tr><tr><td>Named supports: 4 shoes</td><td>each <code>zmin</code> ≤ 1e-3</td><td>4, shoe_z 0.00000</td></tr><tr><td>Stone size</td><td>0.500 m dia × 0.095 m thick ± 0.02 / ± 0.015</td><td>0.5000 × 0.0950</td></tr><tr><td>Edge treatment</td><td>manifold edges within 5° of 90° = 0</td><td>0 wood, 0 stone, 0 iron</td></tr></tbody></table></div>
+<p>The coplanar budget counts pairs from different shells within 0.05 m, using <code>hay-bale</code>&#x27;s constants. The first build matched only faces whose centres fell within 0.1 mm of each other, and no real overlap ever does. It reported 0 while the shoes shared three planes with every sill end, seen as a lit slit in each foot close-up.</p>
 <h3>Joint fit and seat</h3>
-<div class="table-wrap"><table><thead><tr><th scope="col">Axis</th><th scope="col">Declared</th><th scope="col">Measured (all three)</th></tr></thead><tbody><tr><td>Crank-axle gap</td><td>≤ 0.008 m</td><td>0.00418</td></tr><tr><td>Shoe-wood BVH gap</td><td>≤ 0.008 m (overlap is 0)</td><td>0.00000</td></tr><tr><td>Trough-sill per-side gap</td><td>≤ 0.008 m (overlap is 0)</td><td>0.00000</td></tr><tr><td>Stone dip into trough</td><td>0.015–0.045 m</td><td>0.02570</td></tr><tr><td>Trough floor zmin</td><td>≥ 0.040 m</td><td>0.05800</td></tr></tbody></table></div>
-<p>DECIMATE COLLAPSE triangle counts are <strong>not</strong> identical across series — 5.2.1 is leaner on LOD2. The gate is a ratio band, not an exact count. Bake pixels are stochastic; the gate is <code>has_data</code> plus operator <code>FINISHED</code>, not byte-identity. Construction uses no RNG. Export byte counts differ by 4 B on 5.2.1 (glTF serializer), not a gated axis.</p>
-<h3>Falsifiers</h3>
-<p>Each violates one named budget. All nine were run on 4.5.11, 5.1.2 and 5.2.1 and returned the same code on each.</p>
-<div class="table-wrap"><table><thead><tr><th scope="col">Flag</th><th scope="col">Budget violated</th><th scope="col">Exit</th></tr></thead><tbody><tr><td><code>--skip-decimate</code></td><td>LOD1 ratio band</td><td>9</td></tr><tr><td><code>--stray-vert</code></td><td>loose vertex count is 0</td><td>15</td></tr><tr><td><code>--lift-z</code></td><td>bounding box <code>zmin</code> is 0</td><td>16</td></tr><tr><td><code>--short-legs</code></td><td>named shoe supports at Z=0</td><td>16</td></tr><tr><td><code>--float-crank</code></td><td>crank-axle gap</td><td>17</td></tr><tr><td><code>--float-legs</code></td><td>shoe-wood join</td><td>17</td></tr><tr><td><code>--no-dip</code></td><td>stone dip band</td><td>18</td></tr><tr><td><code>--narrow-trough</code></td><td>trough-sill seat</td><td>18</td></tr></tbody></table></div>
+<div class="table-wrap"><table><thead><tr><th scope="col">Axis</th><th scope="col">Declared</th><th scope="col">Measured (all three)</th></tr></thead><tbody><tr><td>Crank-axle gap</td><td>≤ 0.008 m</td><td>0.00376</td></tr><tr><td>Shoe-wood BVH gap</td><td>≤ 0.008 m (overlap is 0)</td><td>0.00000</td></tr><tr><td>Trough-sill per-side gap</td><td>≤ 0.008 m (overlap is 0)</td><td>0.00000</td></tr><tr><td>Stone dip into trough</td><td>0.015–0.045 m</td><td>0.02416</td></tr><tr><td>Trough floor zmin</td><td>≥ 0.040 m</td><td>0.05800</td></tr><tr><td>Trough bearing</td><td>2 end stretchers, each biting the trough floor 0.002–0.008 m</td><td>2, [0.00400, 0.00400]</td></tr></tbody></table></div>
+<p>DECIMATE COLLAPSE triangle counts can differ across series, so 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> plus the texel floor, not byte-identity. Per-member wood tone comes from <code>random.Random(TONE_SEED)</code>, so it is identical run to run. Export byte counts differ by 12 B on 5.2.1 (glTF serializer), which is not a gated axis.</p>
+<h2>Falsifiers</h2>
+<p>Each violates one named budget. All thirteen were run on 4.5.11, 5.1.2 and 5.2.1 and returned the same code on each.</p>
+<div class="table-wrap"><table><thead><tr><th scope="col">Flag</th><th scope="col">Budget violated</th><th scope="col">Exit</th></tr></thead><tbody><tr><td><code>--skip-decimate</code></td><td>LOD1 ratio band</td><td>9</td></tr><tr><td><code>--stray-vert</code></td><td>loose vertex count is 0</td><td>15</td></tr><tr><td><code>--flush-shoes</code></td><td>coplanar cross-shell pairs: shoes sized to the sill and flush with its end (0 → 4 pairs)</td><td>15</td></tr><tr><td><code>--lift-z</code></td><td>bounding box <code>zmin</code> is 0</td><td>16</td></tr><tr><td><code>--short-legs</code></td><td>named shoe supports at Z=0</td><td>16</td></tr><tr><td><code>--float-crank</code></td><td>crank-axle gap</td><td>17</td></tr><tr><td><code>--float-legs</code></td><td>shoe-wood join</td><td>17</td></tr><tr><td><code>--narrow-trough</code></td><td>trough-sill seat</td><td>18</td></tr><tr><td><code>--no-dip</code></td><td>stone dip band</td><td>18</td></tr><tr><td><code>--low-stretchers</code></td><td>trough bearing: stretchers back at sill height, 5.9 mm under the trough</td><td>18</td></tr><tr><td><code>--sharp-handle</code></td><td>edge treatment: the crank handle&#x27;s rims left square (20 right-angle edges)</td><td>20</td></tr><tr><td><code>--low-bake</code></td><td>bake texel density: 256 px bake (7.36 px per cell)</td><td>21</td></tr></tbody></table></div>
+<p><code>--flush-shoes</code> moves the shoe envelope 12 mm inside <code>BBOX_TOL</code> (15 mm), so the AABB gate cannot steal it. <code>--sharp-handle</code> leaves the triangle count inside its band, so only the edge budget sees it.</p>
 <h2>Run</h2>
 <pre><code>blender --background --python grindstone.py --
 blender --background --python grindstone.py -- --skip-decimate
 blender --background --python grindstone.py -- --stray-vert
+blender --background --python grindstone.py -- --flush-shoes
 blender --background --python grindstone.py -- --lift-z
 blender --background --python grindstone.py -- --short-legs
 blender --background --python grindstone.py -- --float-crank
 blender --background --python grindstone.py -- --float-legs
-blender --background --python grindstone.py -- --no-dip
 blender --background --python grindstone.py -- --narrow-trough
+blender --background --python grindstone.py -- --no-dip
+blender --background --python grindstone.py -- --low-stretchers
+blender --background --python grindstone.py -- --sharp-handle
+blender --background --python grindstone.py -- --low-bake
 blender --background --python grindstone.py -- --output grindstone.png</code></pre>
 <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. <code>15</code>–<code>19</code> are the hygiene and joint-fit family.</p>
-<div class="table-wrap"><table><thead><tr><th scope="col">Code</th><th scope="col">Meaning</th></tr></thead><tbody><tr><td>0</td><td>Success</td></tr><tr><td>1</td><td>Uncaught exception (FATAL wrapper)</td></tr><tr><td>2</td><td>argparse / usage</td></tr><tr><td>3</td><td>Mesh did not build / no UV layer</td></tr><tr><td>4</td><td>Base triangle count outside range</td></tr><tr><td>5</td><td>Material count ≠ 3 distinct slots, or a face-count floor missed</td></tr><tr><td>6</td><td>UVs outside 0..1</td></tr><tr><td>7</td><td>UV AABB overlap above tolerance</td></tr><tr><td>8</td><td>World AABB off declared outer size</td></tr><tr><td>9</td><td>LOD ratio band (<code>--skip-decimate</code> lands here)</td></tr><tr><td>10</td><td>Framing gate (render path only)</td></tr><tr><td>11</td><td>Collider triangle count above ceiling</td></tr><tr><td>12</td><td>Bake did not finish or image has no data</td></tr><tr><td>13</td><td>Export file missing or empty</td></tr><tr><td>14</td><td><code>--output</code> produced no file</td></tr><tr><td>15</td><td>Mesh hygiene: loose, non-manifold, zero-area, doubles, n-gons, z-fight</td></tr><tr><td>16</td><td>Not grounded: bounding box <code>zmin</code> off 0, or a named shoe floats</td></tr><tr><td>17</td><td>Joint fit: crank-axle gap, or shoe-wood join</td></tr><tr><td>18</td><td>Seat: trough-sill gap, stone dip band, or trough sitting on the dirt</td></tr><tr><td>19</td><td>Stone diameter or thickness off the stated real-world size</td></tr></tbody></table></div>
+<div class="table-wrap"><table><thead><tr><th scope="col">Code</th><th scope="col">Meaning</th></tr></thead><tbody><tr><td>0</td><td>Success</td></tr><tr><td>1</td><td>Uncaught exception (FATAL wrapper)</td></tr><tr><td>2</td><td>argparse / usage</td></tr><tr><td>3</td><td>Mesh did not build / no UV layer</td></tr><tr><td>4</td><td>Base triangle count outside range</td></tr><tr><td>5</td><td>Material count ≠ 3 distinct slots, or a face-count floor missed</td></tr><tr><td>6</td><td>UVs outside 0..1</td></tr><tr><td>7</td><td>UV AABB overlap above tolerance</td></tr><tr><td>8</td><td>World AABB off declared outer size</td></tr><tr><td>9</td><td>LOD ratio band (<code>--skip-decimate</code> lands here)</td></tr><tr><td>10</td><td>Framing gate (render path only)</td></tr><tr><td>11</td><td>Collider triangle count above ceiling</td></tr><tr><td>12</td><td>Bake did not finish or image has no data</td></tr><tr><td>13</td><td>Export file missing or empty</td></tr><tr><td>14</td><td><code>--output</code> produced no file</td></tr><tr><td>15</td><td>Mesh hygiene: loose, non-manifold, zero-area, doubles, n-gons, coplanar cross-shell pairs</td></tr><tr><td>16</td><td>Not grounded: bounding box <code>zmin</code> off 0, or a named shoe floats</td></tr><tr><td>17</td><td>Joint fit: crank-axle gap, or shoe-wood join</td></tr><tr><td>18</td><td>Seat: trough-sill gap, stone dip band, trough on the dirt, or trough not bearing on its stretchers</td></tr><tr><td>19</td><td>Stone diameter or thickness off the stated real-world size</td></tr><tr><td>20</td><td>A right-angle edge survived the chamfer passes (<code>--sharp-handle</code> lands here)</td></tr><tr><td>21</td><td>Bake texel density below the floor (<code>--low-bake</code> lands here)</td></tr></tbody></table></div>
     </section>
     <section class="detail-section src">
       <h2>Source</h2>
@@ -327,18 +334,25 @@ <h2>Source</h2>
 Budgets are declared below and recomputed from the generated result.
 They are not API-contract witnesses. ``--skip-decimate`` skips the LOD
 DECIMATE stage so the LOD-ratio budget fails. ``--stray-vert`` adds a
-loose vertex so the mesh-hygiene budget fails. ``--lift-z`` raises the
-mesh so the grounded-zmin budget fails. ``--float-crank`` offsets the
-crank from the axle so joint-fit fails. ``--no-dip`` raises the stone
-clear of the trough so the seat-conformance dip band fails.
-``--short-legs`` raises the iron shoes and plants a dummy so the named
-support budget fails while AABB zmin still passes. ``--float-legs``
-lifts the A-frame timber off the shoes so the shoe-wood join fails.
-``--narrow-trough`` shrinks the tub so it no longer seats in the sills.
-
-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.
+loose vertex so the mesh-hygiene budget fails. ``--flush-shoes`` sizes
+the iron shoes to the sill so their faces share its planes and the
+coplanar budget fails. ``--lift-z`` raises the mesh so the
+grounded-zmin budget fails. ``--short-legs`` raises the iron shoes and
+plants a dummy so the named support budget fails while AABB zmin still
+passes. ``--float-crank`` offsets the crank from the axle so joint-fit
+fails. ``--float-legs`` lifts the A-frame timber off the shoes so the
+shoe-wood join fails. ``--narrow-trough`` shrinks the tub so it no
+longer seats in the sills. ``--no-dip`` raises the stone clear of the
+trough so the seat-conformance dip band fails. ``--low-stretchers``
+drops the end stretchers under the trough so it no longer bears on
+them. ``--sharp-handle`` leaves the crank handle unchamfered so the
+edge-treatment budget fails. ``--low-bake`` bakes at 256 px so the
+texel-density budget fails.
+
+Seeded, not random: per-member tone uses ``random.Random(TONE_SEED)``.
+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.
 
     blender --background --python grindstone.py --
     blender --background --python grindstone.py -- --skip-decimate
@@ -347,6 +361,7 @@ <h2>Source</h2>
 <span class="k">import</span> argparse
 <span class="k">import</span> math
 <span class="k">import</span> os
+<span class="k">import</span> random
 <span class="k">import</span> sys
 <span class="k">import</span> tempfile
 <span class="k">import</span> traceback
@@ -355,6 +370,7 @@ <h2>Source</h2>
 <span class="k">import</span> bpy
 <span class="k">from</span> mathutils <span class="k">import</span> Euler, Vector
 <span class="k">from</span> mathutils.bvhtree <span class="k">import</span> BVHTree
+<span class="k">from</span> mathutils.kdtree <span class="k">import</span> KDTree
 
 _REPO = os.path.abspath(
     os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir, os.pardir)
@@ -365,7 +381,10 @@ <h2>Source</h2>
 
 STONE_R = <span class="n">0.250</span>
 STONE_T = <span class="n">0.095</span>
-STONE_SEGS = <span class="n">32</span>
+<span class="c"># 32 flat-shaded segments read as a polygon in the front orthographic and</span>
+<span class="c"># threw one highlight per facet across the tread. 48 smooth segments with</span>
+<span class="c"># hard chamfer rings read as a turned wheel.</span>
+STONE_SEGS = <span class="n">48</span>
 CHAMFER = <span class="n">0.012</span>
 TROUGH_H = <span class="n">0.080</span>
 TROUGH_WALL = <span class="n">0.018</span>
@@ -380,7 +399,13 @@ <h2>Source</h2>
 <span class="c"># tenon *into* the frame. Matching Y-thickness puts coplanar faces</span>
 <span class="c"># on the camera side and reads as a black hole in the timber.</span>
 SILL_Y = <span class="n">0.070</span>
+KING_X = <span class="n">0.052</span>
 KING_Y = <span class="n">0.054</span>
+<span class="c"># Each diagonal tenons into the king post&#x27;s face by a named bite. Run to</span>
+<span class="c"># the king&#x27;s centre line, the pair met at one apex and their chamfered</span>
+<span class="c"># end faces landed on each other inside the bearing: 6 coplanar pairs.</span>
+DIAG_BITE = <span class="n">0.012</span>
+SILL_END = LEG_SPREAD + <span class="n">0.035</span>
 <span class="c"># Seat the tub into the sill inner faces. Deriving from LEG_XY left a</span>
 <span class="c"># daylight slot once the sill was fattened to nest the diagonals.</span>
 TROUGH_SEAT = <span class="n">0.012</span>
@@ -392,15 +417,39 @@ <h2>Source</h2>
 CRANK_ARM = <span class="n">0.13</span>
 HANDLE_L = <span class="n">0.11</span>
 SHOE_H = <span class="n">0.024</span>
-SHOE_XY = (<span class="n">0.070</span>, <span class="n">0.070</span>)
+<span class="c"># An iron shoe is a cup round the sill&#x27;s end, a named reveal proud of it</span>
+<span class="c"># on every side. The first build made it exactly as wide as the sill and</span>
+<span class="c"># flush with its end, so the two shared three planes per foot: a lit slit</span>
+<span class="c"># in every foot close-up, which a centre-coincidence z-fight test missed.</span>
+SHOE_REVEAL = <span class="n">0.006</span>
+SHOE_CUP = <span class="n">0.064</span>
+<span class="c"># The end stretchers carry the trough: their top is the trough&#x27;s bottom</span>
+<span class="c"># plus a named bite. At sill height they stopped 6 mm short, a dark slit</span>
+<span class="c"># under the tub. Stationed inboard of the shoes, so a stretcher is never</span>
+<span class="c"># the wood a shoe measures against.</span>
+STRETCH_W = <span class="n">0.038</span>
+STRETCH_H = <span class="n">0.035</span>
+STRETCH_CLEAR = <span class="n">0.010</span>
+TROUGH_BITE = <span class="n">0.004</span>
+TROUGH_BITE_MIN = <span class="n">0.002</span>
+TROUGH_BITE_MAX = <span class="n">0.008</span>
+IRON_BEVEL = <span class="n">0.0012</span>
+BEVEL_MIN_ANGLE = math.radians(<span class="n">50.0</span>)
+PLANK_TONE_JITTER = <span class="n">0.26</span>
+TONE_SEED = <span class="n">43</span>
+WOOD_GRAIN_SCALE = <span class="n">30.0</span>
 
 BBOX_TOL = <span class="n">0.015</span>
-OUTER_SIZE = (<span class="n">0.710</span>, <span class="n">0.419</span>, <span class="n">0.610</span>)
+<span class="c"># Shoes one reveal past the sill ends (X); the crank handle (Y); the</span>
+<span class="c"># stone&#x27;s crown (Z). X was 0.710 with flush shoes.</span>
+OUTER_SIZE = (<span class="n">0.722</span>, <span class="n">0.419</span>, <span class="n">0.610</span>)
 STONE_DIA = <span class="n">2.0</span> * STONE_R
 STONE_DIA_TOL = <span class="n">0.02</span>
 STONE_T_TOL = <span class="n">0.015</span>
-BASE_TRIS_MIN = <span class="n">700</span>
-BASE_TRIS_MAX = <span class="n">1000</span>
+<span class="c"># Re-fitted for the rebuild (928 -&gt; 1668: chamfers on every member, a</span>
+<span class="c"># 48-segment stone). Centred on the measurement.</span>
+BASE_TRIS_MIN = <span class="n">1560</span>
+BASE_TRIS_MAX = <span class="n">1780</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>
@@ -410,17 +459,32 @@ <h2>Source</h2>
 MATERIAL_COUNT = <span class="n">3</span>
 UV_EPS = <span class="n">1e-4</span>
 UV_OVERLAP_MAX = <span class="n">1e-5</span>
-COLLIDER_TRIS_MAX = <span class="n">240</span>
-BAKE_RES = <span class="n">256</span>
-CAGE_EXTRUSION = <span class="n">0.08</span>
-METAL_FACES_MIN = <span class="n">80</span>
-WOOD_FACES_MIN = <span class="n">80</span>
-STONE_FACES_MIN = <span class="n">80</span>
+<span class="c"># Re-fitted: the 48-segment stone adds hull vertices (198 -&gt; 304).</span>
+COLLIDER_TRIS_MAX = <span class="n">320</span>
+<span class="c"># One UV cell per face; 256 px left each cell under 12 texels, so the</span>
+<span class="c"># bilinear lookup read neighbouring cells&#x27; normals (tavern-stool&#x27;s defect).</span>
+BAKE_RES = <span class="n">1024</span>
+LOW_BAKE_RES = <span class="n">256</span>
+TEXEL_MIN = <span class="n">12.0</span>
+<span class="c"># The cage covers the chamfer difference between high and low (under</span>
+<span class="c"># 2 mm); a wide one reaches the next part and bakes its surface instead.</span>
+CAGE_EXTRUSION = <span class="n">0.01</span>
+<span class="c"># About 70% of each measured count; the first build&#x27;s 80 apiece let most</span>
+<span class="c"># of a material&#x27;s faces go missing unseen.</span>
+METAL_FACES_MIN = <span class="n">260</span>
+WOOD_FACES_MIN = <span class="n">280</span>
+STONE_FACES_MIN = <span class="n">190</span>
 ZMIN_EPS = <span class="n">1e-4</span>
 DOUBLES_EPS = <span class="n">1e-5</span>
 AREA_EPS = <span class="n">1e-10</span>
-ZFIGHT_EPS = <span class="n">1e-4</span>
-ZFIGHT_COS = <span class="n">0.999</span>
+<span class="c"># Z-fighting: two separate bodies landing on one plane. Cross-shell, with</span>
+<span class="c"># hay-bale&#x27;s constants (copied, not imported). The first build matched</span>
+<span class="c"># only faces whose centres fell within 0.1 mm of each other, which no</span>
+<span class="c"># real shoe-on-sill overlap ever does.</span>
+COPLANAR_NORMAL_EPS = <span class="n">1e-4</span>
+COPLANAR_PLANE_EPS = <span class="n">1e-4</span>
+COPLANAR_CENTRE_MAX = <span class="n">0.05</span>
+ZFIGHT_PAIRS_MAX = <span class="n">0</span>
 LIFT_Z = <span class="n">0.05</span>
 CRANK_JOIN = <span class="n">0.008</span>
 SHOE_JOIN = <span class="n">0.008</span>
@@ -429,6 +493,10 @@ <h2>Source</h2>
 DIP_MAX = <span class="n">0.045</span>
 SHOE_Z_MAX = <span class="n">1e-3</span>
 TROUGH_FLOOR_Z_MIN = <span class="n">0.040</span>
+<span class="c"># Edge treatment: every timber and iron edge is chamfered, so a manifold</span>
+<span class="c"># edge still within RIGHT_ANGLE_TOL of 90 degrees is a skipped bevel.</span>
+RIGHT_ANGLE_TOL = math.radians(<span class="n">5.0</span>)
+RIGHT_ANGLE_MAX = <span class="n">0</span>
 
 WOOD_IDX = <span class="n">0</span>
 STONE_IDX = <span class="n">1</span>
@@ -481,6 +549,13 @@ <h2>Source</h2>
     <span class="k">return</span> verts
 
 
+<span class="k">def</span> add_span(bm, lo, hi, mat_idx):
+    <span class="s">&quot;&quot;&quot;Axis-aligned box from its min corner to its max corner.&quot;&quot;&quot;</span>
+    lo = Vector(lo)
+    hi = Vector(hi)
+    <span class="k">return</span> add_box(bm, (lo + hi) * <span class="n">0.5</span>, hi - lo, mat_idx)
+
+
 <span class="k">def</span> add_oriented_box(bm, a, b, scale_xy, mat_idx):
     a = Vector(a)
     b = Vector(b)
@@ -500,10 +575,12 @@ <h2>Source</h2>
 
 
 <span class="k">def</span> add_cyl(bm, loc, radius, depth, segments, mat_idx, euler=(<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>)):
+    <span class="s">&quot;&quot;&quot;Cylinder with n-gon caps; ``finish_caps`` triangulates them after the
+    chamfer pass, which folds a chamfered triangle-fan cap inside out.&quot;&quot;&quot;</span>
     geo = bmesh.ops.create_cone(
         bm,
         cap_ends=<span class="k">True</span>,
-        cap_tris=<span class="k">True</span>,
+        cap_tris=<span class="k">False</span>,
         segments=segments,
         radius1=radius,
         radius2=radius,
@@ -520,6 +597,15 @@ <h2>Source</h2>
     <span class="k">return</span> verts
 
 
+<span class="k">def</span> finish_caps(bm):
+    <span class="s">&quot;&quot;&quot;Triangulate every face with more than four corners.&quot;&quot;&quot;</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, quad_method=<span class="s">&quot;BEAUTY&quot;</span>, ngon_method=<span class="s">&quot;BEAUTY&quot;</span>,
+        )
+
+
 <span class="k">def</span> add_basin(bm, loc, size, wall, mat_idx):
     <span class="s">&quot;&quot;&quot;One manifold open tub. Five overlapping boxes bevel into degenerates.&quot;&quot;&quot;</span>
     geo = bmesh.ops.create_cube(bm, size=<span class="n">1.0</span>)
@@ -645,7 +731,8 @@ <h2>Source</h2>
 <span class="k">def</span> build_grindstone_mesh(
     name, bevel_offset, bevel_segments,
     float_crank=<span class="k">False</span>, no_dip=<span class="k">False</span>, short_legs=<span class="k">False</span>, float_legs=<span class="k">False</span>,
-    narrow_trough=<span class="k">False</span>,
+    narrow_trough=<span class="k">False</span>, flush_shoes=<span class="k">False</span>, low_stretchers=<span class="k">False</span>,
+    sharp_handle=<span class="k">False</span>,
 ):
     bm = bmesh.new()
     <span class="k">try</span>:
@@ -664,22 +751,20 @@ <h2>Source</h2>
         shoe_z = <span class="n">0.05</span> <span class="k">if</span> short_legs <span class="k">else</span> <span class="n">0.0</span>
         bearing_h = <span class="n">0.090</span>
         bearing_xz = (<span class="n">0.078</span>, bearing_h)
-        king_xy = (<span class="n">0.052</span>, KING_Y)
-        <span class="c"># Diagonals *are* the legs. A tall stump beside an angled timber</span>
-        <span class="c"># paints a see-through triangle on the stump face. Bury a short</span>
-        <span class="c"># tenon in the shoe (never proud of the iron) and start the</span>
-        <span class="c"># diagonal on the shoe top so the angled end-cap cannot pierce</span>
-        <span class="c"># Z=0.</span>
-        tenon_z = shoe_z + SHOE_H * <span class="n">0.50</span>
+        king_xy = (KING_X, KING_Y)
+        <span class="c"># Diagonals *are* the legs, and they start in the sill above the</span>
+        <span class="c"># shoe so the angled end-cap cannot pierce Z=0. The first build</span>
+        <span class="c"># also buried a short tenon box in each shoe, wholly hidden inside</span>
+        <span class="c"># sill and iron: triangles nobody could see.</span>
         diag_z = shoe_z + SHOE_H + <span class="n">0.008</span>
         <span class="k">if</span> float_legs:
-            tenon_z = shoe_z + SHOE_H + <span class="n">0.070</span>
             diag_z = shoe_z + SHOE_H + <span class="n">0.070</span>
         sill_h = <span class="n">0.050</span>
         sill_bottom = (
             shoe_z + SHOE_H + <span class="n">0.055</span> <span class="k">if</span> float_legs <span class="k">else</span> shoe_z + SHOE_H * <span class="n">0.40</span>
         )
         sill_z = sill_bottom + sill_h / <span class="n">2.0</span>
+        reveal = <span class="n">0.0</span> <span class="k">if</span> flush_shoes <span class="k">else</span> SHOE_REVEAL
 
         <span class="k">for</span> y <span class="k">in</span> (-FRAME_Y, FRAME_Y):
             <span class="c"># King post fills the A-crotch so the bearing is not a cube</span>
@@ -701,57 +786,52 @@ <h2>Source</h2>
                     WOOD_IDX,
                 )
             )
-            <span class="c"># Tie beam sits on the shoes and occupies the A-foot.</span>
+            <span class="c"># Tie beam sits in the shoes and occupies the A-foot.</span>
             wood.extend(
-                add_box(
+                add_span(
                     bm,
-                    (<span class="n">0.0</span>, y, sill_z),
-                    (LEG_SPREAD * <span class="n">2.0</span> + SHOE_XY[<span class="n">0</span>], SILL_Y, sill_h),
+                    (-SILL_END, y - SILL_Y / <span class="n">2.0</span>, sill_bottom),
+                    (SILL_END, y + SILL_Y / <span class="n">2.0</span>, sill_bottom + sill_h),
                     WOOD_IDX,
                 )
             )
-            <span class="k">for</span> x <span class="k">in</span> (-LEG_SPREAD, LEG_SPREAD):
-                <span class="k">if</span> <span class="k">not</span> float_legs:
-                    wood.extend(
-                        add_box(
-                            bm,
-                            (x, y, tenon_z),
-                            (LEG_XY[<span class="n">0</span>] * <span class="n">0.92</span>, LEG_XY[<span class="n">1</span>] * <span class="n">0.92</span>, SHOE_H * <span class="n">0.90</span>),
-                            WOOD_IDX,
-                        )
-                    )
+            <span class="k">for</span> s <span class="k">in</span> (-<span class="n">1.0</span>, <span class="n">1.0</span>):
                 wood.extend(
                     add_oriented_box(
                         bm,
-                        (x, y, diag_z),
-                        (<span class="n">0.0</span>, y, axle_z - <span class="n">0.010</span>),
+                        (s * LEG_SPREAD, y, diag_z),
+                        (s * (KING_X / <span class="n">2.0</span> - DIAG_BITE), y, axle_z - <span class="n">0.010</span>),
                         LEG_XY,
                         WOOD_IDX,
                     )
                 )
+                x_in, x_out = SILL_END - SHOE_CUP, SILL_END + reveal
                 metal.extend(
-                    add_box(
+                    add_span(
                         bm,
-                        (x, y, shoe_z + SHOE_H / <span class="n">2.0</span>),
-                        (SHOE_XY[<span class="n">0</span>], SHOE_XY[<span class="n">1</span>], SHOE_H),
+                        (min(s * x_in, s * x_out), y - SILL_Y / <span class="n">2.0</span> - reveal, shoe_z),
+                        (max(s * x_in, s * x_out), y + SILL_Y / <span class="n">2.0</span> + reveal,
+                         shoe_z + SHOE_H),
                         METAL_IDX,
                     )
                 )
 
-        <span class="k">for</span> x <span class="k">in</span> (-LEG_SPREAD, LEG_SPREAD):
-            <span class="c"># End stretchers tenon through both sills at sill height.</span>
-            <span class="c"># A higher independent Z left them floating as extra cubes.</span>
+        <span class="c"># End stretchers tenon through both sills and carry the trough.</span>
+        stretch_top = TROUGH_Z0 + TROUGH_BITE
+        <span class="k">if</span> low_stretchers:
+            stretch_top = sill_z + sill_h * <span class="n">0.35</span>
+        stretch_x = SILL_END - SHOE_CUP - STRETCH_CLEAR - STRETCH_W / <span class="n">2.0</span>
+        <span class="k">for</span> s <span class="k">in</span> (-<span class="n">1.0</span>, <span class="n">1.0</span>):
             wood.extend(
-                add_box(
+                add_span(
                     bm,
-                    (x, <span class="n">0.0</span>, sill_z),
-                    (<span class="n">0.038</span>, FRAME_Y * <span class="n">2.0</span>, sill_h * <span class="n">0.70</span>),
+                    (s * stretch_x - STRETCH_W / <span class="n">2.0</span>, -FRAME_Y, stretch_top - STRETCH_H),
+                    (s * stretch_x + STRETCH_W / <span class="n">2.0</span>, FRAME_Y, stretch_top),
                     WOOD_IDX,
                 )
             )
 
         tw = TROUGH_W * (<span class="n">0.58</span> <span class="k">if</span> narrow_trough <span class="k">else</span> <span class="n">1.0</span>)
-        chamfer = []
         basin_verts = add_basin(
             bm,
             (<span class="n">0.0</span>, <span class="n">0.0</span>, tub_z0 + TROUGH_H / <span class="n">2.0</span>),
@@ -759,9 +839,9 @@ <h2>Source</h2>
             TROUGH_WALL,
             WOOD_IDX,
         )
-        chamfer.extend(basin_verts)
+        wood.extend(basin_verts)
 
-        chamfer.extend(
+        handle = set(
             add_cyl(
                 bm,
                 (<span class="n">0.0</span>, crank_y + HANDLE_L * <span class="n">0.15</span>, axle_z + CRANK_ARM),
@@ -772,7 +852,7 @@ <h2>Source</h2>
                 euler=(math.pi / <span class="n">2.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>),
             )
         )
-        wood.extend(chamfer)
+        wood.extend(handle)
 
         add_stone(bm, (<span class="n">0.0</span>, <span class="n">0.0</span>), axle_z)
 
@@ -837,44 +917,110 @@ <h2>Source</h2>
             v.co.x -= cx
             v.co.y -= cy
 
+        bm.edges.index_update()
+
+        <span class="k">def</span> sharp(edge, idx):
+            <span class="k">if</span> len(edge.link_faces) != <span class="n">2</span>:
+                <span class="k">return</span> <span class="k">False</span>
+            <span class="k">if</span> any(f.material_index != idx <span class="k">for</span> f <span class="k">in</span> edge.link_faces):
+                <span class="k">return</span> <span class="k">False</span>
+            <span class="c"># --sharp-handle leaves the crank handle&#x27;s rims square: a few</span>
+            <span class="c"># dozen triangles short, inside the triangle band, so only</span>
+            <span class="c"># the edge budget can see it.</span>
+            <span class="k">if</span> sharp_handle <span class="k">and</span> all(v <span class="k">in</span> handle <span class="k">for</span> v <span class="k">in</span> edge.verts):
+                <span class="k">return</span> <span class="k">False</span>
+            <span class="k">return</span> edge.calc_face_angle(<span class="n">0.0</span>) &gt; BEVEL_MIN_ANGLE
+
         <span class="k">if</span> bevel_offset &gt; <span class="n">0.0</span>:
-            edges = []
-            trough_verts = set(basin_verts)
-            <span class="k">for</span> e <span class="k">in</span> {e <span class="k">for</span> v <span class="k">in</span> trough_verts <span class="k">for</span> e <span class="k">in</span> v.link_edges}:
-                <span class="k">if</span> min(v.co.z <span class="k">for</span> v <span class="k">in</span> e.verts) &lt; tub_z0 - <span class="n">0.002</span>:
-                    <span class="k">continue</span>
-                <span class="k">if</span> any(f.material_index != WOOD_IDX <span class="k">for</span> f <span class="k">in</span> e.link_faces):
-                    <span class="k">continue</span>
-                edges.append(e)
-            <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 = WOOD_IDX
+            edges = sorted(
+                (e <span class="k">for</span> e <span class="k">in</span> bm.edges <span class="k">if</span> sharp(e, WOOD_IDX)), key=<span class="k">lambda</span> e: e.index
+            )
+            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>, material=WOOD_IDX,
+            )
+            bm.edges.index_update()
+            edges = sorted(
+                (e <span class="k">for</span> e <span class="k">in</span> bm.edges <span class="k">if</span> sharp(e, METAL_IDX)), key=<span class="k">lambda</span> e: e.index
+            )
+            bmesh.ops.bevel(
+                bm, geom=edges, offset=IRON_BEVEL, segments=<span class="n">1</span>, profile=<span class="n">0.5</span>,
+                affect=<span class="s">&quot;EDGES&quot;</span>, clamp_overlap=<span class="k">True</span>, material=METAL_IDX,
+            )
+        finish_caps(bm)
 
         pack_uvs(bm)
         bmesh.ops.recalc_face_normals(bm, faces=list(bm.faces))
+        <span class="c"># Smooth across the stone&#x27;s and the round irons&#x27; facets; hard at</span>
+        <span class="c"># every chamfer and material boundary. The stone&#x27;s chamfer rings</span>
+        <span class="c"># meet its tread at 32 degrees, so its threshold is lower.</span>
         <span class="k">for</span> face <span class="k">in</span> bm.faces:
-            face.smooth = <span class="k">False</span>
+            face.smooth = <span class="k">True</span>
+        <span class="k">for</span> edge <span class="k">in</span> bm.edges:
+            edge.smooth = <span class="k">True</span>
+            <span class="k">if</span> len(edge.link_faces) == <span class="n">2</span>:
+                f0, f1 = edge.link_faces
+                limit = math.radians(
+                    <span class="n">25.0</span> <span class="k">if</span> f0.material_index == STONE_IDX <span class="k">else</span> <span class="n">35.0</span>
+                )
+                <span class="k">if</span> (f0.material_index != f1.material_index
+                        <span class="k">or</span> edge.calc_face_angle(<span class="n">0.0</span>) &gt; limit):
+                    edge.smooth = <span class="k">False</span>
         me = bpy.data.meshes.new(name)
         bm.to_mesh(me)
         me.update()
-        <span class="k">for</span> poly <span class="k">in</span> me.polygons:
-            poly.use_smooth = <span class="k">False</span>
     <span class="k">finally</span>:
         bm.free()
+    paint_planks(me)
     out = bpy.data.objects.new(name, me)
     bpy.context.collection.objects.link(out)
     <span class="k">return</span> out
 
 
+<span class="k">def</span> _long_axis(pts):
+    <span class="s">&quot;&quot;&quot;Principal axis of a point set, by power iteration on its covariance.&quot;&quot;&quot;</span>
+    c = sum(pts, Vector()) / len(pts)
+    cov = [[<span class="n">0.0</span>] * <span class="n">3</span> <span class="k">for</span> _ <span class="k">in</span> range(<span class="n">3</span>)]
+    <span class="k">for</span> p <span class="k">in</span> pts:
+        d = p - c
+        <span class="k">for</span> i <span class="k">in</span> range(<span class="n">3</span>):
+            <span class="k">for</span> j <span class="k">in</span> range(<span class="n">3</span>):
+                cov[i][j] += d[i] * d[j]
+    v = Vector((<span class="n">1.0</span>, <span class="n">0.3</span>, <span class="n">0.1</span>))
+    <span class="k">for</span> _ <span class="k">in</span> range(<span class="n">30</span>):
+        w = Vector([sum(cov[i][j] * v[j] <span class="k">for</span> j <span class="k">in</span> range(<span class="n">3</span>)) <span class="k">for</span> i <span class="k">in</span> range(<span class="n">3</span>)])
+        <span class="k">if</span> w.length &lt; <span class="n">1e-12</span>:
+            <span class="k">break</span>
+        v = w.normalized()
+    <span class="k">return</span> v
+
+
+<span class="k">def</span> paint_planks(me):
+    <span class="s">&quot;&quot;&quot;Per-shell ``PlankTone`` and ``GrainDir`` face attributes for the wood shader.
+
+    Every sill, diagonal, king, bearing and stretcher is its own shell, so
+    each gets one seeded tone and grain along its own long axis.
+    &quot;&quot;&quot;</span>
+    tone = [<span class="n">0.5</span>] * len(me.polygons)
+    grain = [(<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">1.0</span>)] * len(me.polygons)
+    owner = {}
+    rng = random.Random(TONE_SEED)
+    <span class="k">for</span> g <span class="k">in</span> sorted(shells(me), key=min):
+        pts = [me.vertices[i].co.copy() <span class="k">for</span> i <span class="k">in</span> g]
+        d = _long_axis(pts) <span class="k">if</span> len(pts) &gt; <span class="n">2</span> <span class="k">else</span> Vector((<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">1.0</span>))
+        t = <span class="n">0.5</span> + rng.uniform(-PLANK_TONE_JITTER, PLANK_TONE_JITTER)
+        <span class="k">for</span> i <span class="k">in</span> g:
+            owner[i] = (t, tuple(d))
+    <span class="k">for</span> poly <span class="k">in</span> me.polygons:
+        t, d = owner[poly.vertices[<span class="n">0</span>]]
+        tone[poly.index] = t
+        grain[poly.index] = d
+    a = me.attributes.new(<span class="s">&quot;PlankTone&quot;</span>, <span class="s">&quot;FLOAT&quot;</span>, <span class="s">&quot;FACE&quot;</span>)
+    a.data.foreach_set(<span class="s">&quot;value&quot;</span>, tone)
+    b = me.attributes.new(<span class="s">&quot;GrainDir&quot;</span>, <span class="s">&quot;FLOAT_VECTOR&quot;</span>, <span class="s">&quot;FACE&quot;</span>)
+    b.data.foreach_set(<span class="s">&quot;vector&quot;</span>, [c <span class="k">for</span> v <span class="k">in</span> grain <span class="k">for</span> c <span class="k">in</span> v])
+
+
 <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>
@@ -905,6 +1051,136 @@ <h2>Source</h2>
     <span class="k">return</span> mat
 
 
+<span class="k">def</span> _sock(sockets, identifier):
+    <span class="s">&quot;&quot;&quot;A Mix-node socket by identifier; its A/B/Result names repeat per type.&quot;&quot;&quot;</span>
+    <span class="k">return</span> next(sk <span class="k">for</span> sk <span class="k">in</span> sockets <span class="k">if</span> sk.identifier == identifier)
+
+
+<span class="k">def</span> wood_material(name):
+    <span class="s">&quot;&quot;&quot;Grain along each member (``GrainDir``), tone per member (``PlankTone``).
+
+    Copied from showcase/wheelbarrow (do not import across pieces).
+    &quot;&quot;&quot;</span>
+    mat = bpy.data.materials.new(name)
+    mat.use_nodes = <span class="k">True</span>
+    nt = mat.node_tree
+    bsdf = nt.nodes[<span class="s">&quot;Principled BSDF&quot;</span>]
+    coord = nt.nodes.new(<span class="s">&quot;ShaderNodeTexCoord&quot;</span>)
+    gdir = nt.nodes.new(<span class="s">&quot;ShaderNodeAttribute&quot;</span>)
+    gdir.attribute_name = <span class="s">&quot;GrainDir&quot;</span>
+    tone = nt.nodes.new(<span class="s">&quot;ShaderNodeAttribute&quot;</span>)
+    tone.attribute_name = <span class="s">&quot;PlankTone&quot;</span>
+    dot = nt.nodes.new(<span class="s">&quot;ShaderNodeVectorMath&quot;</span>)
+    dot.operation = <span class="s">&quot;DOT_PRODUCT&quot;</span>
+    nt.links.new(coord.outputs[<span class="s">&quot;Object&quot;</span>], dot.inputs[<span class="n">0</span>])
+    nt.links.new(gdir.outputs[<span class="s">&quot;Vector&quot;</span>], dot.inputs[<span class="n">1</span>])
+    squash = nt.nodes.new(<span class="s">&quot;ShaderNodeMath&quot;</span>)
+    squash.operation = <span class="s">&quot;MULTIPLY&quot;</span>
+    squash.inputs[<span class="n">1</span>].default_value = <span class="n">0.94</span>
+    nt.links.new(dot.outputs[<span class="s">&quot;Value&quot;</span>], squash.inputs[<span class="n">0</span>])
+    along = nt.nodes.new(<span class="s">&quot;ShaderNodeVectorMath&quot;</span>)
+    along.operation = <span class="s">&quot;SCALE&quot;</span>
+    nt.links.new(gdir.outputs[<span class="s">&quot;Vector&quot;</span>], along.inputs[<span class="n">0</span>])
+    nt.links.new(squash.outputs[<span class="s">&quot;Value&quot;</span>], along.inputs[<span class="s">&quot;Scale&quot;</span>])
+    grain_co = nt.nodes.new(<span class="s">&quot;ShaderNodeVectorMath&quot;</span>)
+    grain_co.operation = <span class="s">&quot;SUBTRACT&quot;</span>
+    nt.links.new(coord.outputs[<span class="s">&quot;Object&quot;</span>], grain_co.inputs[<span class="n">0</span>])
+    nt.links.new(along.outputs[<span class="s">&quot;Vector&quot;</span>], grain_co.inputs[<span class="n">1</span>])
+    shift = nt.nodes.new(<span class="s">&quot;ShaderNodeVectorMath&quot;</span>)
+    shift.operation = <span class="s">&quot;ADD&quot;</span>
+    nt.links.new(grain_co.outputs[<span class="s">&quot;Vector&quot;</span>], shift.inputs[<span class="n">0</span>])
+    nt.links.new(tone.outputs[<span class="s">&quot;Fac&quot;</span>], shift.inputs[<span class="n">1</span>])
+    noise = nt.nodes.new(<span class="s">&quot;ShaderNodeTexNoise&quot;</span>)
+    noise.inputs[<span class="s">&quot;Scale&quot;</span>].default_value = WOOD_GRAIN_SCALE
+    noise.inputs[<span class="s">&quot;Detail&quot;</span>].default_value = <span class="n">6.0</span>
+    noise.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.62</span>
+    nt.links.new(shift.outputs[<span class="s">&quot;Vector&quot;</span>], noise.inputs[<span class="s">&quot;Vector&quot;</span>])
+    ramp = nt.nodes.new(<span class="s">&quot;ShaderNodeValToRGB&quot;</span>)
+    ramp.color_ramp.elements[<span class="n">0</span>].position = <span class="n">0.30</span>
+    ramp.color_ramp.elements[<span class="n">0</span>].color = (<span class="n">0.12</span>, <span class="n">0.052</span>, <span class="n">0.018</span>, <span class="n">1.0</span>)
+    ramp.color_ramp.elements[<span class="n">1</span>].position = <span class="n">0.72</span>
+    ramp.color_ramp.elements[<span class="n">1</span>].color = (<span class="n">0.38</span>, <span class="n">0.18</span>, <span class="n">0.065</span>, <span class="n">1.0</span>)
+    nt.links.new(noise.outputs[<span class="s">&quot;Fac&quot;</span>], ramp.inputs[<span class="s">&quot;Fac&quot;</span>])
+    gain = nt.nodes.new(<span class="s">&quot;ShaderNodeMath&quot;</span>)
+    gain.operation = <span class="s">&quot;MULTIPLY_ADD&quot;</span>
+    gain.inputs[<span class="n">1</span>].default_value = <span class="n">1.1</span>
+    gain.inputs[<span class="n">2</span>].default_value = <span class="n">0.45</span>
+    nt.links.new(tone.outputs[<span class="s">&quot;Fac&quot;</span>], gain.inputs[<span class="n">0</span>])
+    mix = nt.nodes.new(<span class="s">&quot;ShaderNodeMix&quot;</span>)
+    mix.data_type = <span class="s">&quot;RGBA&quot;</span>
+    mix.blend_type = <span class="s">&quot;MULTIPLY&quot;</span>
+    _sock(mix.inputs, <span class="s">&quot;Factor_Float&quot;</span>).default_value = <span class="n">1.0</span>
+    nt.links.new(ramp.outputs[<span class="s">&quot;Color&quot;</span>], _sock(mix.inputs, <span class="s">&quot;A_Color&quot;</span>))
+    nt.links.new(gain.outputs[<span class="s">&quot;Value&quot;</span>], _sock(mix.inputs, <span class="s">&quot;B_Color&quot;</span>))
+    nt.links.new(_sock(mix.outputs, <span class="s">&quot;Result_Color&quot;</span>), bsdf.inputs[<span class="s">&quot;Base Color&quot;</span>])
+    rough = nt.nodes.new(<span class="s">&quot;ShaderNodeMapRange&quot;</span>)
+    rough.inputs[<span class="s">&quot;To Min&quot;</span>].default_value = <span class="n">0.72</span>
+    rough.inputs[<span class="s">&quot;To Max&quot;</span>].default_value = <span class="n">0.52</span>
+    nt.links.new(noise.outputs[<span class="s">&quot;Fac&quot;</span>], rough.inputs[<span class="s">&quot;Value&quot;</span>])
+    nt.links.new(rough.outputs[<span class="s">&quot;Result&quot;</span>], bsdf.inputs[<span class="s">&quot;Roughness&quot;</span>])
+    <span class="k">return</span> mat
+
+
+<span class="k">def</span> stone_material(name):
+    <span class="s">&quot;&quot;&quot;Sandstone: isotropic object-space mottling, fine speckle driving
+    roughness and a small bump. The first build&#x27;s pale noise mix rendered
+    the wheel chalk-white, a plastic disc rather than a quarried stone.
+    &quot;&quot;&quot;</span>
+    mat = bpy.data.materials.new(name)
+    mat.use_nodes = <span class="k">True</span>
+    nt = mat.node_tree
+    bsdf = nt.nodes[<span class="s">&quot;Principled BSDF&quot;</span>]
+    coord = nt.nodes.new(<span class="s">&quot;ShaderNodeTexCoord&quot;</span>)
+    mottle = nt.nodes.new(<span class="s">&quot;ShaderNodeTexNoise&quot;</span>)
+    mottle.inputs[<span class="s">&quot;Scale&quot;</span>].default_value = <span class="n">7.0</span>
+    mottle.inputs[<span class="s">&quot;Detail&quot;</span>].default_value = <span class="n">5.0</span>
+    mottle.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.6</span>
+    nt.links.new(coord.outputs[<span class="s">&quot;Object&quot;</span>], mottle.inputs[<span class="s">&quot;Vector&quot;</span>])
+    ramp = nt.nodes.new(<span class="s">&quot;ShaderNodeValToRGB&quot;</span>)
+    ramp.color_ramp.elements[<span class="n">0</span>].position = <span class="n">0.32</span>
+    ramp.color_ramp.elements[<span class="n">0</span>].color = (<span class="n">0.20</span>, <span class="n">0.16</span>, <span class="n">0.115</span>, <span class="n">1.0</span>)
+    ramp.color_ramp.elements[<span class="n">1</span>].position = <span class="n">0.70</span>
+    ramp.color_ramp.elements[<span class="n">1</span>].color = (<span class="n">0.34</span>, <span class="n">0.28</span>, <span class="n">0.20</span>, <span class="n">1.0</span>)
+    nt.links.new(mottle.outputs[<span class="s">&quot;Fac&quot;</span>], ramp.inputs[<span class="s">&quot;Fac&quot;</span>])
+    speck = nt.nodes.new(<span class="s">&quot;ShaderNodeTexNoise&quot;</span>)
+    speck.inputs[<span class="s">&quot;Scale&quot;</span>].default_value = <span class="n">220.0</span>
+    speck.inputs[<span class="s">&quot;Detail&quot;</span>].default_value = <span class="n">2.0</span>
+    nt.links.new(coord.outputs[<span class="s">&quot;Object&quot;</span>], speck.inputs[<span class="s">&quot;Vector&quot;</span>])
+    grit = nt.nodes.new(<span class="s">&quot;ShaderNodeMix&quot;</span>)
+    grit.data_type = <span class="s">&quot;RGBA&quot;</span>
+    grit.blend_type = <span class="s">&quot;MULTIPLY&quot;</span>
+    _sock(grit.inputs, <span class="s">&quot;Factor_Float&quot;</span>).default_value = <span class="n">0.35</span>
+    nt.links.new(ramp.outputs[<span class="s">&quot;Color&quot;</span>], _sock(grit.inputs, <span class="s">&quot;A_Color&quot;</span>))
+    nt.links.new(speck.outputs[<span class="s">&quot;Color&quot;</span>], _sock(grit.inputs, <span class="s">&quot;B_Color&quot;</span>))
+    nt.links.new(_sock(grit.outputs, <span class="s">&quot;Result_Color&quot;</span>), bsdf.inputs[<span class="s">&quot;Base Color&quot;</span>])
+    rough = nt.nodes.new(<span class="s">&quot;ShaderNodeMapRange&quot;</span>)
+    rough.inputs[<span class="s">&quot;To Min&quot;</span>].default_value = <span class="n">0.80</span>
+    rough.inputs[<span class="s">&quot;To Max&quot;</span>].default_value = <span class="n">0.96</span>
+    nt.links.new(speck.outputs[<span class="s">&quot;Fac&quot;</span>], rough.inputs[<span class="s">&quot;Value&quot;</span>])
+    nt.links.new(rough.outputs[<span class="s">&quot;Result&quot;</span>], bsdf.inputs[<span class="s">&quot;Roughness&quot;</span>])
+    bump = nt.nodes.new(<span class="s">&quot;ShaderNodeBump&quot;</span>)
+    bump.inputs[<span class="s">&quot;Strength&quot;</span>].default_value = <span class="n">0.18</span>
+    bump.inputs[<span class="s">&quot;Distance&quot;</span>].default_value = <span class="n">0.002</span>
+    nt.links.new(speck.outputs[<span class="s">&quot;Fac&quot;</span>], bump.inputs[<span class="s">&quot;Height&quot;</span>])
+    nt.links.new(bump.outputs[<span class="s">&quot;Normal&quot;</span>], bsdf.inputs[<span class="s">&quot;Normal&quot;</span>])
+    <span class="k">return</span> mat
+
+
+<span class="k">def</span> grindstone_materials():
+    <span class="s">&quot;&quot;&quot;(wood, stone, iron): shared by the check, the render and inspection.
+
+    Forged iron is dark and rusted. The first build&#x27;s metallic 1.0 at 0.38
+    roughness rendered hubs and shoes as black plastic.
+    &quot;&quot;&quot;</span>
+    wood = wood_material(<span class="s">&quot;GrindstoneWood&quot;</span>)
+    stone = stone_material(<span class="s">&quot;GrindstoneStone&quot;</span>)
+    metal = principled(
+        <span class="s">&quot;GrindstoneIron&quot;</span>, (<span class="n">0.17</span>, <span class="n">0.165</span>, <span class="n">0.155</span>, <span class="n">1.0</span>), <span class="n">0.80</span>, <span class="n">0.46</span>,
+        noise_scale=<span class="n">18.0</span>, wear=(<span class="n">0.20</span>, <span class="n">0.085</span>, <span class="n">0.032</span>, <span class="n">1.0</span>),
+    )
+    <span class="k">return</span> wood, stone, metal
+
+
 <span class="k">def</span> assign_slots(obj, wood, stone, metal):
     mats = obj.data.materials
     wanted = (wood, stone, metal)
@@ -983,24 +1259,39 @@ <h2>Source</h2>
 
 
 <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="s">&quot;&quot;&quot;Coplanar face pairs from *different shells* — the z-fighting budget.
+
+    Cross-shell, not merely share-no-vertex: two quads on one flat face of
+    a chamfered box share no vertex and are coplanar by construction.
+    Z-fighting is two separate bodies landing on one plane. Combinatorics
+    and constants copied from showcase/hay-bale (do not import across
+    pieces); candidate pairs come from a KD-tree range query at
+    COPLANAR_CENTRE_MAX.
+    &quot;&quot;&quot;</span>
+    owner = {}
+    <span class="k">for</span> si, g <span class="k">in</span> enumerate(shells(me)):
+        <span class="k">for</span> vi <span class="k">in</span> g:
+            owner[vi] = si
+    faces = [(p.normal.copy(), p.center.copy(), owner.get(p.vertices[<span class="n">0</span>], -<span class="n">1</span>))
+             <span class="k">for</span> p <span class="k">in</span> me.polygons]
+    kd = KDTree(len(faces))
+    <span class="k">for</span> i, (_n, c, _s) <span class="k">in</span> enumerate(faces):
+        kd.insert(c, i)
+    kd.balance()
+    hits = <span class="n">0</span>
+    <span class="k">for</span> i, (ni, ci, si) <span class="k">in</span> enumerate(faces):
+        <span class="k">for</span> _co, j, _d <span class="k">in</span> kd.find_range(ci, COPLANAR_CENTRE_MAX):
+            <span class="k">if</span> j &lt;= i:
+                <span class="k">continue</span>
+            nj, cj, sj = faces[j]
+            <span class="k">if</span> si == sj:
                 <span class="k">continue</span>
-            <span class="k">if</span> abs(ni.dot(nj)) &lt;= ZFIGHT_COS:
+            <span class="k">if</span> abs(abs(ni.dot(nj)) - <span class="n">1.0</span>) &gt; COPLANAR_NORMAL_EPS:
                 <span class="k">continue</span>
-            <span class="k">if</span> vi &amp; vj:
+            <span class="k">if</span> abs(ni.dot(cj - ci)) &gt; COPLANAR_PLANE_EPS:
                 <span class="k">continue</span>
-            count += <span class="n">1</span>
-    <span class="k">return</span> count
+            hits += <span class="n">1</span>
+    <span class="k">return</span> hits
 
 
 <span class="k">def</span> shells(me):
@@ -1071,6 +1362,17 @@ <h2>Source</h2>
     <span class="k">return</span> best
 
 
+<span class="k">def</span> _trough_box(me, groups):
+    <span class="k">for</span> g <span class="k">in</span> groups:
+        <span class="k">if</span> mat_of(me, g) != WOOD_IDX:
+            <span class="k">continue</span>
+        a = shell_aabb(me, g)
+        dx, dy = a[<span class="n">3</span>] - a[<span class="n">0</span>], a[<span class="n">4</span>] - a[<span class="n">1</span>]
+        <span class="k">if</span> abs(dx - TROUGH_L) &lt; <span class="n">0.08</span> <span class="k">and</span> dy &gt; <span class="n">0.08</span> <span class="k">and</span> a[<span class="n">2</span>] &lt; <span class="n">0.15</span>:
+            <span class="k">return</span> a
+    <span class="k">return</span> <span class="k">None</span>
+
+
 <span class="k">def</span> stone_audit(me):
     stone_pts = []
     groups = shells(me)
@@ -1088,15 +1390,7 @@ <h2>Source</h2>
     dia = max(max(xs) - min(xs), max(zs) - min(zs))
     thick = max(ys) - min(ys)
     zmin = min(zs)
-    tb = <span class="k">None</span>
-    <span class="k">for</span> g <span class="k">in</span> groups:
-        <span class="k">if</span> mat_of(me, g) != WOOD_IDX:
-            <span class="k">continue</span>
-        a = shell_aabb(me, g)
-        dx, dy = a[<span class="n">3</span>] - a[<span class="n">0</span>], a[<span class="n">4</span>] - a[<span class="n">1</span>]
-        <span class="k">if</span> abs(dx - TROUGH_L) &lt; <span class="n">0.08</span> <span class="k">and</span> dy &gt; <span class="n">0.08</span> <span class="k">and</span> a[<span class="n">2</span>] &lt; <span class="n">0.15</span>:
-            tb = a
-            <span class="k">break</span>
+    tb = _trough_box(me, groups)
     trough_z = tb[<span class="n">2</span>] <span class="k">if</span> tb <span class="k">else</span> trough_floor_z(me)
     trough_top = tb[<span class="n">5</span>] <span class="k">if</span> tb <span class="k">else</span> (TROUGH_Z0 + TROUGH_H)
     <span class="k">return</span> {
@@ -1108,6 +1402,28 @@ <h2>Source</h2>
     }
 
 
+<span class="k">def</span> trough_bearing(me):
+    <span class="s">&quot;&quot;&quot;How deep the trough&#x27;s floor bites each end stretcher.
+
+    Stretchers are the wood shells that cross the frame in Y and are
+    short in X and Z, read off the mesh and counted, so a dropped
+    stretcher cannot pass vacuously. A trough resting a few millimetres
+    above its bearers passes the sill seat and the dip band; this is the
+    budget that sees the slit.
+    &quot;&quot;&quot;</span>
+    groups = shells(me)
+    tb = _trough_box(me, groups)
+    bites = []
+    <span class="k">for</span> g <span class="k">in</span> groups:
+        <span class="k">if</span> mat_of(me, g) != WOOD_IDX:
+            <span class="k">continue</span>
+        a = shell_aabb(me, g)
+        dx, dy, dz = a[<span class="n">3</span>] - a[<span class="n">0</span>], a[<span class="n">4</span>] - a[<span class="n">1</span>], a[<span class="n">5</span>] - a[<span class="n">2</span>]
+        <span class="k">if</span> dx &lt; <span class="n">0.06</span> <span class="k">and</span> dy &gt; <span class="n">1.5</span> * FRAME_Y <span class="k">and</span> dz &lt; <span class="n">0.05</span>:
+            bites.append(a[<span class="n">5</span>] - tb[<span class="n">2</span>] <span class="k">if</span> tb <span class="k">else</span> -<span class="n">1.0</span>)
+    <span class="k">return</span> bites
+
+
 <span class="k">def</span> crank_join(me):
     <span class="s">&quot;&quot;&quot;Gap from crank-arm verts to the axle shell.&quot;&quot;&quot;</span>
     groups = shells(me)
@@ -1231,6 +1547,47 @@ <h2>Source</h2>
         bm_wood.free()
 
 
+<span class="k">def</span> right_angle_edges(me):
+    <span class="s">&quot;&quot;&quot;Manifold edges whose two faces meet at 90 degrees, iron and timber.
+
+    Every box and cylinder in the piece is chamfered, and a chamfer turns
+    a 90-degree edge into two shallower ones. An edge still at 90 is one a
+    bevel pass skipped: the razor edge that renders as a hard black line.
+    Copied from showcase/crate-stack (do not import across pieces).
+    &quot;&quot;&quot;</span>
+    counts = {WOOD_IDX: <span class="n">0</span>, STONE_IDX: <span class="n">0</span>, METAL_IDX: <span class="n">0</span>}
+    bm = bmesh.new()
+    <span class="k">try</span>:
+        bm.from_mesh(me)
+        <span class="k">for</span> e <span class="k">in</span> bm.edges:
+            <span class="k">if</span> len(e.link_faces) != <span class="n">2</span>:
+                <span class="k">continue</span>
+            <span class="k">if</span> abs(e.calc_face_angle(<span class="n">0.0</span>) - math.pi / <span class="n">2.0</span>) &lt;= RIGHT_ANGLE_TOL:
+                idx = e.link_faces[<span class="n">0</span>].material_index
+                counts[idx] = counts.get(idx, <span class="n">0</span>) + <span class="n">1</span>
+    <span class="k">finally</span>:
+        bm.free()
+    <span class="k">return</span> counts
+
+
+<span class="k">def</span> texel_audit(mesh, img):
+    <span class="s">&quot;&quot;&quot;Smallest UV cell, in baked texels along its longer side.
+
+    Copied from showcase/tavern-stool (do not import across pieces).
+    &quot;&quot;&quot;</span>
+    uv = mesh.uv_layers.active
+    <span class="k">if</span> uv <span class="k">is</span> <span class="k">None</span> <span class="k">or</span> img <span class="k">is</span> <span class="k">None</span>:
+        <span class="k">return</span> <span class="n">0.0</span>
+    res = min(img.size[<span class="n">0</span>], img.size[<span class="n">1</span>])
+    data = uv.data
+    worst = <span class="n">1e9</span>
+    <span class="k">for</span> poly <span class="k">in</span> mesh.polygons:
+        us = [data[i].uv[<span class="n">0</span>] <span class="k">for</span> i <span class="k">in</span> poly.loop_indices]
+        vs = [data[i].uv[<span class="n">1</span>] <span class="k">for</span> i <span class="k">in</span> poly.loop_indices]
+        worst = min(worst, max(max(us) - min(us), max(vs) - min(vs)) * res)
+    <span class="k">return</span> worst
+
+
 <span class="k">def</span> add_stray_vert(me):
     bm = bmesh.new()
     <span class="k">try</span>:
@@ -1328,31 +1685,26 @@ <h2>Source</h2>
     )
 
 
+<span class="k">def</span> _no():
+    <span class="k">return</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">def</span> check(
     skip_decimate, lift_z=<span class="k">False</span>, stray_vert=<span class="k">False</span>,
     float_crank=<span class="k">False</span>, no_dip=<span class="k">False</span>, short_legs=<span class="k">False</span>, float_legs=<span class="k">False</span>,
-    narrow_trough=<span class="k">False</span>,
+    narrow_trough=<span class="k">False</span>, flush_shoes=<span class="k">False</span>, low_stretchers=<span class="k">False</span>,
+    sharp_handle=<span class="k">False</span>, low_bake=<span class="k">False</span>,
 ):
     bpy.ops.wm.read_factory_settings(use_empty=<span class="k">True</span>)
     flags = dict(
         float_crank=float_crank, no_dip=no_dip,
         short_legs=short_legs, float_legs=float_legs,
-        narrow_trough=narrow_trough,
-    )
-    low = build_grindstone_mesh(<span class="s">&quot;GrindstoneLow&quot;</span>, <span class="n">0.004</span>, <span class="n">2</span>, **flags)
-    high = build_grindstone_mesh(<span class="s">&quot;GrindstoneHigh&quot;</span>, <span class="n">0.004</span>, <span class="n">4</span>, **flags)
-    wood = principled(
-        <span class="s">&quot;GrindstoneWood&quot;</span>, (<span class="n">0.38</span>, <span class="n">0.20</span>, <span class="n">0.08</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.62</span>,
-        noise_scale=<span class="n">6.5</span>, wear=(<span class="n">0.22</span>, <span class="n">0.11</span>, <span class="n">0.04</span>, <span class="n">1.0</span>),
-    )
-    stone = principled(
-        <span class="s">&quot;GrindstoneStone&quot;</span>, (<span class="n">0.40</span>, <span class="n">0.36</span>, <span class="n">0.30</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.92</span>,
-        noise_scale=<span class="n">14.0</span>, wear=(<span class="n">0.28</span>, <span class="n">0.24</span>, <span class="n">0.18</span>, <span class="n">1.0</span>),
-    )
-    metal = principled(
-        <span class="s">&quot;GrindstoneIron&quot;</span>, (<span class="n">0.14</span>, <span class="n">0.145</span>, <span class="n">0.155</span>, <span class="n">1.0</span>), <span class="n">1.0</span>, <span class="n">0.38</span>,
-        noise_scale=<span class="n">5.0</span>, wear=(<span class="n">0.05</span>, <span class="n">0.05</span>, <span class="n">0.06</span>, <span class="n">1.0</span>),
+        narrow_trough=narrow_trough, flush_shoes=flush_shoes,
+        low_stretchers=low_stretchers, sharp_handle=sharp_handle,
     )
+    low = build_grindstone_mesh(<span class="s">&quot;GrindstoneLow&quot;</span>, <span class="n">0.004</span>, <span class="n">1</span>, **flags)
+    high = build_grindstone_mesh(<span class="s">&quot;GrindstoneHigh&quot;</span>, <span class="n">0.004</span>, <span class="n">3</span>, **flags)
+    wood, stone, metal = grindstone_materials()
     assign_slots(low, wood, stone, metal)
     assign_slots(high, wood, stone, metal)
     <span class="k">if</span> stray_vert:
@@ -1364,7 +1716,7 @@ <h2>Source</h2>
         bpy.context.view_layer.update()
 
     <span class="k">if</span> low.data <span class="k">is</span> <span class="k">None</span> <span class="k">or</span> len(low.data.polygons) &lt; <span class="n">6</span>:
-        <span class="k">return</span> fail(<span class="s">&quot;grindstone 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>
+        <span class="k">return</span> (fail(<span class="s">&quot;grindstone mesh did not build&quot;</span>, <span class="n">3</span>),) + _no()
 
     base_tris = triangle_count(low.data)
     mats = [s <span class="k">for</span> s <span class="k">in</span> low.data.materials <span class="k">if</span> s <span class="k">is</span> <span class="k">not</span> <span class="k">None</span>]
@@ -1380,10 +1732,11 @@ <h2>Source</h2>
     size_y = bb[<span class="n">4</span>] - bb[<span class="n">1</span>]
     size_z = bb[<span class="n">5</span>] - bb[<span class="n">2</span>]
 
-    img, tex = setup_bake_image(low, stone)
+    img, tex = setup_bake_image(low, stone, LOW_BAKE_RES <span class="k">if</span> low_bake <span class="k">else</span> BAKE_RES)
     <span class="k">if</span> img <span class="k">is</span> <span class="k">None</span>:
-        <span class="k">return</span> fail(<span class="s">&quot;grindstone has no UV layer&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>
+        <span class="k">return</span> (fail(<span class="s">&quot;grindstone has no UV layer&quot;</span>, <span class="n">3</span>),) + _no()
     bake_result = bake_normal(high, low)
+    texel = texel_audit(low.data, img)
 
     lod1 = make_lod(low, <span class="s">&quot;GrindstoneLOD1&quot;</span>, LOD1_TARGET, skip_decimate)
     lod2 = make_lod(low, <span class="s">&quot;GrindstoneLOD2&quot;</span>, LOD2_TARGET, skip_decimate)
@@ -1406,6 +1759,11 @@ <h2>Source</h2>
         os.remove(export_path)
     export_unity(export_path, [low, collider])
     export_size = os.path.getsize(export_path) <span class="k">if</span> os.path.isfile(export_path) <span class="k">else</span> <span class="n">0</span>
+    <span class="k">if</span> os.path.isfile(export_path):
+        <span class="k">try</span>:
+            os.remove(export_path)
+        <span class="k">except</span> OSError:
+            <span class="k">pass</span>
 
     hyg = hygiene_audit(low.data)
     zf = zfight_pairs(low.data)
@@ -1414,6 +1772,11 @@ <h2>Source</h2>
     cj = crank_join(low.data)
     sw = shoe_wood_gap(low.data)
     ts = trough_sill_gap(low.data)
+    bites = trough_bearing(low.data)
+    right_angles = right_angle_edges(low.data)
+    n_right_angles = sum(right_angles.values())
+    bite_lo = min(bites) <span class="k">if</span> bites <span class="k">else</span> -<span class="n">1.0</span>
+    bite_hi = max(bites) <span class="k">if</span> bites <span class="k">else</span> <span class="n">1e9</span>
 
     print(<span class="s">f&quot;</span><span class="s">blender=</span>{tuple(bpy.app.version)}<span class="s"> skip_decimate=</span>{skip_decimate}<span class="s">&quot;</span>)
     print(
@@ -1430,7 +1793,8 @@ <h2>Source</h2>
     )
     print(
         <span class="s">f&quot;</span><span class="s">measured collider_tris=</span>{col_tris}<span class="s"> bake=</span>{bake_result}<span class="s"> </span><span class="s">&quot;</span>
-        <span class="s">f&quot;</span><span class="s">bake_has_data=</span>{img.has_data}<span class="s"> export_bytes=</span>{export_size}<span class="s">&quot;</span>
+        <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"> </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">bake_res=</span>{img.size[<span class="n">0</span>]}<span class="s"> texel_min=</span>{texel:<span class="s">.2f</span>}<span class="s">&quot;</span>
     )
     print(
         <span class="s">f&quot;</span><span class="s">measured hygiene loose_v=</span>{hyg[<span class="s">&#x27;loose_v&#x27;</span>]}<span class="s"> loose_e=</span>{hyg[<span class="s">&#x27;loose_e&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
@@ -1443,152 +1807,162 @@ <h2>Source</h2>
         <span class="s">f&quot;</span><span class="s">dip=</span>{st[<span class="s">&#x27;dip&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> trough_z=</span>{st[<span class="s">&#x27;trough_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">crank_join=</span>{cj:<span class="s">.5f</span>}<span class="s"> shoe_wood=</span>{sw:<span class="s">.5f</span>}<span class="s"> trough_sill=</span>{ts:<span class="s">.5f</span>}<span class="s">&quot;</span>
     )
+    print(
+        <span class="s">f&quot;</span><span class="s">measured trough_bearing=</span>{len(bites)}<span class="s"> stretchers </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">bite=[</span>{bite_lo:<span class="s">.5f</span>}<span class="s">,</span>{bite_hi:<span class="s">.5f</span>}<span class="s">] right_angle_edges=</span>{right_angles}<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(
-            <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>,
-            <span class="n">4</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> (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>, <span class="n">4</span>,
+        ),) + _no()
     <span class="k">if</span> nmat != MATERIAL_COUNT <span class="k">or</span> distinct_mats != MATERIAL_COUNT:
-        <span class="k">return</span> fail(
-            <span class="s">f&quot;</span><span class="s">material slots </span>{nmat}<span class="s"> distinct </span>{distinct_mats}<span class="s"> != </span>{MATERIAL_COUNT}<span class="s">&quot;</span>,
-            <span class="n">5</span>,
-        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+        <span class="k">return</span> (fail(
+            <span class="s">f&quot;</span><span class="s">material slots </span>{nmat}<span class="s"> distinct </span>{distinct_mats}<span class="s"> != </span>{MATERIAL_COUNT}<span class="s">&quot;</span>, <span class="n">5</span>,
+        ),) + _no()
     <span class="k">if</span> idx_counts.get(METAL_IDX, <span class="n">0</span>) &lt; METAL_FACES_MIN:
-        <span class="k">return</span> fail(
-            <span class="s">f&quot;</span><span class="s">metal faces </span>{idx_counts.get(METAL_IDX, <span class="n">0</span>)}<span class="s"> &lt; </span>{METAL_FACES_MIN}<span class="s">&quot;</span>,
-            <span class="n">5</span>,
-        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+        <span class="k">return</span> (fail(
+            <span class="s">f&quot;</span><span class="s">metal faces </span>{idx_counts.get(METAL_IDX, <span class="n">0</span>)}<span class="s"> &lt; </span>{METAL_FACES_MIN}<span class="s">&quot;</span>, <span class="n">5</span>,
+        ),) + _no()
     <span class="k">if</span> idx_counts.get(STONE_IDX, <span class="n">0</span>) &lt; STONE_FACES_MIN:
-        <span class="k">return</span> fail(
-            <span class="s">f&quot;</span><span class="s">stone faces </span>{idx_counts.get(STONE_IDX, <span class="n">0</span>)}<span class="s"> &lt; </span>{STONE_FACES_MIN}<span class="s">&quot;</span>,
-            <span class="n">5</span>,
-        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+        <span class="k">return</span> (fail(
+            <span class="s">f&quot;</span><span class="s">stone faces </span>{idx_counts.get(STONE_IDX, <span class="n">0</span>)}<span class="s"> &lt; </span>{STONE_FACES_MIN}<span class="s">&quot;</span>, <span class="n">5</span>,
+        ),) + _no()
     <span class="k">if</span> idx_counts.get(WOOD_IDX, <span class="n">0</span>) &lt; WOOD_FACES_MIN:
-        <span class="k">return</span> fail(
-            <span class="s">f&quot;</span><span class="s">wood faces </span>{idx_counts.get(WOOD_IDX, <span class="n">0</span>)}<span class="s"> &lt; </span>{WOOD_FACES_MIN}<span class="s">&quot;</span>,
-            <span class="n">5</span>,
-        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+        <span class="k">return</span> (fail(
+            <span class="s">f&quot;</span><span class="s">wood faces </span>{idx_counts.get(WOOD_IDX, <span class="n">0</span>)}<span class="s"> &lt; </span>{WOOD_FACES_MIN}<span class="s">&quot;</span>, <span class="n">5</span>,
+        ),) + _no()
     <span class="k">if</span> u0 &lt; -UV_EPS <span class="k">or</span> v0 &lt; -UV_EPS <span class="k">or</span> u1 &gt; <span class="n">1.0</span> + UV_EPS <span class="k">or</span> v1 &gt; <span class="n">1.0</span> + UV_EPS:
-        <span class="k">return</span> fail(
-            <span class="s">f&quot;</span><span class="s">UVs outside 0..1: (</span>{u0:<span class="s">.4f</span>}<span class="s">,</span>{v0:<span class="s">.4f</span>}<span class="s">)-(</span>{u1:<span class="s">.4f</span>}<span class="s">,</span>{v1:<span class="s">.4f</span>}<span class="s">)</span><span class="s">&quot;</span>,
-            <span class="n">6</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> (fail(
+            <span class="s">f&quot;</span><span class="s">UVs outside 0..1: (</span>{u0:<span class="s">.4f</span>}<span class="s">,</span>{v0:<span class="s">.4f</span>}<span class="s">)-(</span>{u1:<span class="s">.4f</span>}<span class="s">,</span>{v1:<span class="s">.4f</span>}<span class="s">)</span><span class="s">&quot;</span>, <span class="n">6</span>,
+        ),) + _no()
     <span class="k">if</span> overlap &gt; UV_OVERLAP_MAX:
-        <span class="k">return</span> fail(
-            <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">return</span> (fail(<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>),) + _no()
     <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
         <span class="k">or</span> abs(size_z - OUTER_SIZE[<span class="n">2</span>]) &gt; BBOX_TOL
     ):
-        <span class="k">return</span> fail(
-            <span class="s">f&quot;</span><span class="s">bbox (</span>{size_x:<span class="s">.4f</span>}<span class="s">,</span>{size_y:<span class="s">.4f</span>}<span class="s">,</span>{size_z:<span class="s">.4f</span>}<span class="s">) </span><span class="s">&quot;</span>
-            <span class="s">f&quot;</span><span class="s">off outer </span>{OUTER_SIZE}<span class="s">&quot;</span>,
-            <span class="n">8</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> (fail(
+            <span class="s">f&quot;</span><span class="s">bbox (</span>{size_x:<span class="s">.4f</span>}<span class="s">,</span>{size_y:<span class="s">.4f</span>}<span class="s">,</span>{size_z:<span class="s">.4f</span>}<span class="s">) off outer </span>{OUTER_SIZE}<span class="s">&quot;</span>, <span class="n">8</span>,
+        ),) + _no()
     <span class="k">if</span> <span class="k">not</span> (LOD1_RATIO_MIN &lt;= r1 &lt;= LOD1_RATIO_MAX):
-        <span class="k">return</span> fail(
+        <span class="k">return</span> (fail(
             <span class="s">f&quot;</span><span class="s">LOD1 ratio </span>{r1:<span class="s">.4f</span>}<span class="s"> not in [</span>{LOD1_RATIO_MIN}<span class="s">, </span>{LOD1_RATIO_MAX}<span class="s">] </span><span class="s">&quot;</span>
             <span class="s">&quot;(--skip-decimate is the designed fail)&quot;</span>,
             <span class="n">9</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>
+        ),) + _no()
     <span class="k">if</span> <span class="k">not</span> (LOD2_RATIO_MIN &lt;= r2 &lt;= LOD2_RATIO_MAX):
-        <span class="k">return</span> fail(
-            <span class="s">f&quot;</span><span class="s">LOD2 ratio </span>{r2:<span class="s">.4f</span>}<span class="s"> not in [</span>{LOD2_RATIO_MIN}<span class="s">, </span>{LOD2_RATIO_MAX}<span class="s">]</span><span class="s">&quot;</span>,
-            <span class="n">9</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> (fail(
+            <span class="s">f&quot;</span><span class="s">LOD2 ratio </span>{r2:<span class="s">.4f</span>}<span class="s"> not in [</span>{LOD2_RATIO_MIN}<span class="s">, </span>{LOD2_RATIO_MAX}<span class="s">]</span><span class="s">&quot;</span>, <span class="n">9</span>,
+        ),) + _no()
     <span class="k">if</span> col_tris &gt; COLLIDER_TRIS_MAX:
-        <span class="k">return</span> fail(
-            <span class="s">f&quot;</span><span class="s">collider tris </span>{col_tris}<span class="s"> &gt; </span>{COLLIDER_TRIS_MAX}<span class="s">&quot;</span>,
-            <span class="n">11</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> (fail(<span class="s">f&quot;</span><span class="s">collider tris </span>{col_tris}<span class="s"> &gt; </span>{COLLIDER_TRIS_MAX}<span class="s">&quot;</span>, <span class="n">11</span>),) + _no()
     <span class="k">if</span> bake_result != {<span class="s">&quot;FINISHED&quot;</span>} <span class="k">or</span> <span class="k">not</span> img.has_data:
-        <span class="k">return</span> fail(
-            <span class="s">f&quot;</span><span class="s">bake failed result=</span>{bake_result}<span class="s"> has_data=</span>{img.has_data}<span class="s">&quot;</span>,
-            <span class="n">12</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> (fail(
+            <span class="s">f&quot;</span><span class="s">bake failed result=</span>{bake_result}<span class="s"> has_data=</span>{img.has_data}<span class="s">&quot;</span>, <span class="n">12</span>,
+        ),) + _no()
     <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">return</span> (fail(<span class="s">&quot;export file missing or empty&quot;</span>, <span class="n">13</span>),) + _no()
     <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="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="s">f&quot;</span><span class="s">doubles=</span>{hyg[<span class="s">&#x27;doubles&#x27;</span>]}<span class="s"> ngons=</span>{hyg[<span class="s">&#x27;ngons&#x27;</span>]}<span class="s"> zfight=</span>{zf}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">&quot;(--stray-vert and --flush-shoes are the designed fails)&quot;</span>,
             <span class="n">15</span>,
-        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+        ),) + _no()
     <span class="k">if</span> abs(bb[<span class="n">2</span>]) &gt; ZMIN_EPS:
-        <span class="k">return</span> fail(
+        <span class="k">return</span> (fail(
             <span class="s">f&quot;</span><span class="s">zmin </span>{bb[<span class="n">2</span>]:<span class="s">.6f</span>}<span class="s"> not within </span>{ZMIN_EPS}<span class="s"> of 0 </span><span class="s">&quot;</span>
             <span class="s">&quot;(--lift-z is the designed fail)&quot;</span>,
             <span class="n">16</span>,
-        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+        ),) + _no()
     <span class="k">if</span> sup[<span class="s">&quot;shoes&quot;</span>] &lt; <span class="n">4</span> <span class="k">or</span> sup[<span class="s">&quot;shoe_z&quot;</span>] &gt; SHOE_Z_MAX:
-        <span class="k">return</span> fail(
+        <span class="k">return</span> (fail(
             <span class="s">f&quot;</span><span class="s">shoe supports </span>{sup[<span class="s">&#x27;shoes&#x27;</span>]}<span class="s"> shoe_z=</span>{sup[<span class="s">&#x27;shoe_z&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> </span><span class="s">&quot;</span>
             <span class="s">&quot;(--short-legs is the designed fail)&quot;</span>,
             <span class="n">16</span>,
-        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+        ),) + _no()
     <span class="k">if</span> cj &gt; CRANK_JOIN:
-        <span class="k">return</span> fail(
+        <span class="k">return</span> (fail(
             <span class="s">f&quot;</span><span class="s">crank-axle gap </span>{cj:<span class="s">.5f</span>}<span class="s"> &gt; </span>{CRANK_JOIN}<span class="s"> </span><span class="s">&quot;</span>
             <span class="s">&quot;(--float-crank is the designed fail)&quot;</span>,
             <span class="n">17</span>,
-        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+        ),) + _no()
     <span class="k">if</span> sw &gt; SHOE_JOIN:
-        <span class="k">return</span> fail(
+        <span class="k">return</span> (fail(
             <span class="s">f&quot;</span><span class="s">shoe-wood gap </span>{sw:<span class="s">.5f</span>}<span class="s"> &gt; </span>{SHOE_JOIN}<span class="s"> </span><span class="s">&quot;</span>
             <span class="s">&quot;(--float-legs is the designed fail)&quot;</span>,
             <span class="n">17</span>,
-        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+        ),) + _no()
     <span class="k">if</span> ts &gt; TROUGH_SILL_JOIN:
-        <span class="k">return</span> fail(
+        <span class="k">return</span> (fail(
             <span class="s">f&quot;</span><span class="s">trough-sill gap </span>{ts:<span class="s">.5f</span>}<span class="s"> &gt; </span>{TROUGH_SILL_JOIN}<span class="s"> </span><span class="s">&quot;</span>
             <span class="s">&quot;(--narrow-trough is the designed fail)&quot;</span>,
             <span class="n">18</span>,
-        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+        ),) + _no()
     <span class="k">if</span> <span class="k">not</span> (DIP_MIN &lt;= st[<span class="s">&quot;dip&quot;</span>] &lt;= DIP_MAX):
-        <span class="k">return</span> fail(
+        <span class="k">return</span> (fail(
             <span class="s">f&quot;</span><span class="s">stone dip </span>{st[<span class="s">&#x27;dip&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> not in [</span>{DIP_MIN}<span class="s">, </span>{DIP_MAX}<span class="s">] </span><span class="s">&quot;</span>
             <span class="s">&quot;(--no-dip is the designed fail)&quot;</span>,
             <span class="n">18</span>,
-        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+        ),) + _no()
     <span class="k">if</span> st[<span class="s">&quot;trough_z&quot;</span>] &lt; TROUGH_FLOOR_Z_MIN:
-        <span class="k">return</span> fail(
+        <span class="k">return</span> (fail(
             <span class="s">f&quot;</span><span class="s">trough floor zmin </span>{st[<span class="s">&#x27;trough_z&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> &lt; </span>{TROUGH_FLOOR_Z_MIN}<span class="s"> </span><span class="s">&quot;</span>
             <span class="s">&quot;(tub must sit on the frame, not the dirt)&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>
+        ),) + _no()
+    <span class="k">if</span> len(bites) != <span class="n">2</span> <span class="k">or</span> bite_lo &lt; TROUGH_BITE_MIN <span class="k">or</span> bite_hi &gt; TROUGH_BITE_MAX:
+        <span class="k">return</span> (fail(
+            <span class="s">f&quot;</span><span class="s">trough bearing: </span>{len(bites)}<span class="s"> stretchers, bite </span><span class="s">&quot;</span>
+            <span class="s">f&quot;</span><span class="s">[</span>{bite_lo:<span class="s">.5f</span>}<span class="s">, </span>{bite_hi:<span class="s">.5f</span>}<span class="s">] outside </span><span class="s">&quot;</span>
+            <span class="s">f&quot;</span><span class="s">[</span>{TROUGH_BITE_MIN}<span class="s">, </span>{TROUGH_BITE_MAX}<span class="s">] </span><span class="s">&quot;</span>
+            <span class="s">&quot;(--low-stretchers is the designed fail: the tub hovers over &quot;</span>
+            <span class="s">&quot;its bearers)&quot;</span>,
+            <span class="n">18</span>,
+        ),) + _no()
     <span class="k">if</span> abs(st[<span class="s">&quot;dia&quot;</span>] - STONE_DIA) &gt; STONE_DIA_TOL:
-        <span class="k">return</span> fail(
-            <span class="s">f&quot;</span><span class="s">stone diameter </span>{st[<span class="s">&#x27;dia&#x27;</span>]:<span class="s">.4f</span>}<span class="s"> off </span>{STONE_DIA}<span class="s">&quot;</span>,
-            <span class="n">19</span>,
-        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+        <span class="k">return</span> (fail(<span class="s">f&quot;</span><span class="s">stone diameter </span>{st[<span class="s">&#x27;dia&#x27;</span>]:<span class="s">.4f</span>}<span class="s"> off </span>{STONE_DIA}<span class="s">&quot;</span>, <span class="n">19</span>),) + _no()
     <span class="k">if</span> abs(st[<span class="s">&quot;thick&quot;</span>] - STONE_T) &gt; STONE_T_TOL:
-        <span class="k">return</span> fail(
-            <span class="s">f&quot;</span><span class="s">stone thickness </span>{st[<span class="s">&#x27;thick&#x27;</span>]:<span class="s">.4f</span>}<span class="s"> off </span>{STONE_T}<span class="s">&quot;</span>,
-            <span class="n">19</span>,
-        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+        <span class="k">return</span> (fail(<span class="s">f&quot;</span><span class="s">stone thickness </span>{st[<span class="s">&#x27;thick&#x27;</span>]:<span class="s">.4f</span>}<span class="s"> off </span>{STONE_T}<span class="s">&quot;</span>, <span class="n">19</span>),) + _no()
+    <span class="k">if</span> n_right_angles &gt; RIGHT_ANGLE_MAX:
+        <span class="k">return</span> (fail(
+            <span class="s">f&quot;</span><span class="s">right-angle edges </span>{right_angles}<span class="s"> &gt; </span>{RIGHT_ANGLE_MAX}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">&quot;(--sharp-handle is the designed fail: the crank handle left &quot;</span>
+            <span class="s">&quot;unchamfered)&quot;</span>,
+            <span class="n">20</span>,
+        ),) + _no()
+    <span class="k">if</span> texel &lt; TEXEL_MIN:
+        <span class="k">return</span> (fail(
+            <span class="s">f&quot;</span><span class="s">bake texel density </span>{texel:<span class="s">.2f</span>}<span class="s"> px per UV cell &lt; </span>{TEXEL_MIN}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">&quot;(--low-bake is the designed fail)&quot;</span>,
+            <span class="n">21</span>,
+        ),) + _no()
     <span class="k">return</span> <span class="n">0</span>, low, high, stone, tex, collider
 
 
 <span class="k">def</span> wire_normal(mat, tex):
+    <span class="s">&quot;&quot;&quot;Chain the baked normal map under the stone&#x27;s bump, not over it.&quot;&quot;&quot;</span>
     nt = mat.node_tree
     bsdf = nt.nodes[<span class="s">&quot;Principled BSDF&quot;</span>]
     nrm = nt.nodes.new(<span class="s">&quot;ShaderNodeNormalMap&quot;</span>)
     nrm.inputs[<span class="s">&quot;Strength&quot;</span>].default_value = <span class="n">1.0</span>
     nt.links.new(tex.outputs[<span class="s">&quot;Color&quot;</span>], nrm.inputs[<span class="s">&quot;Color&quot;</span>])
-    nt.links.new(nrm.outputs[<span class="s">&quot;Normal&quot;</span>], bsdf.inputs[<span class="s">&quot;Normal&quot;</span>])
+    bump = next((n <span class="k">for</span> n <span class="k">in</span> nt.nodes <span class="k">if</span> n.bl_idname == <span class="s">&quot;ShaderNodeBump&quot;</span>), <span class="k">None</span>)
+    <span class="k">if</span> bump <span class="k">is</span> <span class="k">not</span> <span class="k">None</span>:
+        nt.links.new(nrm.outputs[<span class="s">&quot;Normal&quot;</span>], bump.inputs[<span class="s">&quot;Normal&quot;</span>])
+    <span class="k">else</span>:
+        nt.links.new(nrm.outputs[<span class="s">&quot;Normal&quot;</span>], bsdf.inputs[<span class="s">&quot;Normal&quot;</span>])
 
 
-<span class="k">def</span> render_still(low, wood, tex, path, engine):
+<span class="k">def</span> render_still(low, hero_mat, tex, path, engine):
     scene = bpy.context.scene
-    wire_normal(wood, tex)
+    wire_normal(hero_mat, tex)
     <span class="k">for</span> ob <span class="k">in</span> list(scene.objects):
         <span class="k">if</span> ob.type == <span class="s">&quot;MESH&quot;</span> <span class="k">and</span> ob != low:
             ob.hide_render = <span class="k">True</span>
@@ -1600,7 +1974,7 @@ <h2>Source</h2>
     floor_me = bpy.data.meshes.new(<span class="s">&quot;Floor&quot;</span>)
     bm = bmesh.new()
     <span class="k">try</span>:
-        bmesh.ops.create_grid(bm, x_segments=<span class="n">1</span>, y_segments=<span class="n">1</span>, size=<span class="n">14.0</span>)
+        bmesh.ops.create_grid(bm, x_segments=<span class="n">1</span>, y_segments=<span class="n">1</span>, size=<span class="n">60.0</span>)
         bm.to_mesh(floor_me)
     <span class="k">finally</span>:
         bm.free()
@@ -1695,6 +2069,10 @@ <h2>Source</h2>
     p.add_argument(<span class="s">&quot;--short-legs&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
     p.add_argument(<span class="s">&quot;--float-legs&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
     p.add_argument(<span class="s">&quot;--narrow-trough&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--flush-shoes&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--low-stretchers&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--sharp-handle&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--low-bake&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
     args = p.parse_args(argv)
 
     code, low, _high, hero_mat, tex, _col = check(
@@ -1706,6 +2084,10 @@ <h2>Source</h2>
         short_legs=args.short_legs,
         float_legs=args.float_legs,
         narrow_trough=args.narrow_trough,
+        flush_shoes=args.flush_shoes,
+        low_stretchers=args.low_stretchers,
+        sharp_handle=args.sharp_handle,
+        low_bake=args.low_bake,
     )
     <span class="k">if</span> code:
         <span class="k">return</span> code
@@ -1730,7 +2112,7 @@ <h2>Source</h2>
   </main>
   <dialog class="lightbox" id="lightbox" aria-label="Full-size render">
     <button class="lightbox-close" type="button" autofocus>Close</button>
-    <img src="../assets/grindstone-hero.webp" alt="A round grey grindstone with a crank handle, mounted in a wooden A-frame trestle." />
+    <img src="../assets/grindstone-hero.webp" alt="A sandstone grindstone wheel with an iron crank, turning in a chamfered timber A-frame over an open trough, its sills capped by iron shoes." />
   </dialog>
   <footer>
     <div class="statusbar">
diff --git a/docs/gallery/index.html b/docs/gallery/index.html
index c77cb1cd..2dc0eb8e 100644
--- a/docs/gallery/index.html
+++ b/docs/gallery/index.html
@@ -783,7 +783,7 @@ <h2><a href="car-mirror-symmetry/">car-mirror-symmetry</a></h2>
       </article>
       <article class="card" data-tags="attributes mesh rendering">
         <a class="card-media" href="attribute-domain-shear/" tabindex="-1" aria-hidden="true">
-          <img src="assets/attribute-domain-shear-hero.webp" alt="Two octagonal rainbow-coloured caps labelled CORNER and POINT, last write wins, showing different colour blending." loading="lazy" decoding="async" />
+          <img src="assets/attribute-domain-shear-hero.webp" alt="Two rainbow pinwheels on wooden sticks, well apart: CORNER on the left with crisp coloured petals, POINT, last write wins, on the right with colours smeared across the hub." loading="lazy" decoding="async" />
         </a>
         <div class="card-body">
           <h2><a href="attribute-domain-shear/">attribute-domain-shear</a></h2>
@@ -1014,12 +1014,12 @@ <h2><a href="watchtower/">watchtower</a></h2>
       </article>
       <article class="card" data-tags="mesh export showcase">
         <a class="card-media" href="cart/" tabindex="-1" aria-hidden="true">
-          <img src="assets/cart-hero.webp" alt="A two-wheeled wooden cart with spoked wheels, an open box bed and long shafts resting on the floor." loading="lazy" decoding="async" />
+          <img src="assets/cart-hero.webp" alt="A wooden handcart with a planked box bed and iron corner straps on two spoked wheels, standing level on two prop legs with its shafts joined by a pull bar." loading="lazy" decoding="async" />
         </a>
         <div class="card-body">
           <h2><a href="cart/">cart</a></h2>
-          <p class="teaches">A procedural two-wheel wooden cart 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: 2856 tris, two materials with metal and wood face floors, UVs in 0..1 with zero AABB overlap, outer AABB 1.539×0.749×0.640 m, LOD ratios in band, convex collider 154 tris, hygiene zero (loose, non-manifold, doubles, n-gons), zero coplanar cross-shell face pairs, both tyres grounded, tyre seat depth in band over 48 angular stations, the two wheels mirrored within 5e-5 m, grounded zmin, non-empty glTF. --flush-tyre exits 15 on the z-fight budget; --sink-tyre exits 18 on the tyre seat band; --float-wheel exits 16 on the named-support budget; --skew-wheel exits 19 on the wheel mirror; --skip-decimate exits 9 on the LOD1 ratio budget; --lift-z exits 16 on the grounded budget.</p>
+          <p class="teaches">A procedural two-wheel handcart 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: 5284 tris, two materials with metal and wood face floors, UVs in 0..1 with zero AABB overlap, outer AABB 1.580×0.842×0.640 m, LOD ratios in band, convex collider 192 tris, hygiene zero (loose, non-manifold, doubles, n-gons), zero coplanar cross-shell face pairs, both tyres and both prop legs grounded, two wall boards per side with 3 mm seams, tyre seat depth in band over 48 angular stations, every shell in one BVH-contact assembly, the two wheels mirrored within 5e-5 m, no unchamfered right-angle edge, 17.45 bake texels per UV cell, non-empty glTF. --flush-tyre exits 15 on the z-fight budget; --float-wheel and --short-props exit 16 on the named-support budget; --wide-seams exits 17 on the board seams; --sink-tyre exits 18 on the tyre seat band; --lift-bed exits 18 on the one-assembly budget; --skew-wheel exits 19 on the wheel mirror; --sharp-bar exits 20 on edge treatment; --low-bake exits 21 on texel density; --skip-decimate exits 9 on the LOD1 ratio budget; --lift-z exits 16 on the grounded budget.</p>
           <a class="card-link" href="cart/">View showcase piece<span class="sr-only"> cart</span> <span aria-hidden="true">&rarr;</span></a>
         </div>
       </article>
@@ -1080,12 +1080,12 @@ <h2><a href="hitching-post/">hitching-post</a></h2>
       </article>
       <article class="card" data-tags="mesh export showcase">
         <a class="card-media" href="grindstone/" tabindex="-1" aria-hidden="true">
-          <img src="assets/grindstone-hero.webp" alt="A round grey grindstone with a crank handle, mounted in a wooden A-frame trestle." loading="lazy" decoding="async" />
+          <img src="assets/grindstone-hero.webp" alt="A sandstone grindstone wheel with an iron crank, turning in a chamfered timber A-frame over an open trough, its sills capped by iron shoes." loading="lazy" decoding="async" />
         </a>
         <div class="card-body">
           <h2><a href="grindstone/">grindstone</a></h2>
           <p class="teaches">A procedural grindstone on a timber trestle 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: 928 tris, three materials with 216 wood / 160 stone / 180 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.710×0.419×0.610 m, zmin 0, hygiene 0, four shoes planted, trough seated in the sills, stone dip 26 mm, LOD ratios in band (5.2 COLLAPSE leaner on LOD2), convex collider 198 tris, non-empty glTF. --skip-decimate exits 9 on LOD1; --stray-vert exits 15 on hygiene; --lift-z / --short-legs exit 16 on grounded; --float-crank / --float-legs exit 17 on joint fit; --no-dip / --narrow-trough exit 18 on seat.</p>
+          <p class="witnesses"><span class="tag">witnesses</span> Recomputed: 1668 tris, three materials with 400 wood / 240 stone / 364 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.722×0.419×0.610 m, zmin 0, hygiene 0 including zero coplanar cross-shell pairs, four shoes planted, trough seated in the sills and biting both stretchers 4 mm, stone dip 24 mm, no unchamfered right-angle edge, 29.44 bake texels per UV cell, LOD ratios in band, convex collider 304 tris, non-empty glTF. --skip-decimate exits 9 on LOD1; --stray-vert / --flush-shoes exit 15 on hygiene; --lift-z / --short-legs exit 16 on grounded; --float-crank / --float-legs exit 17 on joint fit; --no-dip / --narrow-trough / --low-stretchers exit 18 on seat; --sharp-handle exits 20 on edge treatment; --low-bake exits 21 on texel density.</p>
           <a class="card-link" href="grindstone/">View showcase piece<span class="sr-only"> grindstone</span> <span aria-hidden="true">&rarr;</span></a>
         </div>
       </article>
diff --git a/examples/attribute-domain-shear/README.md b/examples/attribute-domain-shear/README.md
index 53637f1b..dcdd5a58 100644
--- a/examples/attribute-domain-shear/README.md
+++ b/examples/attribute-domain-shear/README.md
@@ -46,6 +46,13 @@ verts into a swirl. The broken state is in-frame by design: the right fan
 (`Specular IOR Level = 0`) so the flat color data carries no specular line,
 per `docs/VISUAL-STYLE.md`.
 
+The staging is render-only and does not touch the checked mesh. The two
+stands are 2.72 m apart so their canopies read as two objects; at 2.30 m the
+petal tips met at the centre of the frame. Each stand's wooden stick runs from
+just below the floor into the hub it carries, both ends derived from the
+stand's tilt. The old dark steel stick stopped 0.6 m short of the hub, under
+the canopy, and disappeared into the stage.
+
 ## Run
 
 ```bash
diff --git a/examples/attribute-domain-shear/attribute_domain_shear.py b/examples/attribute-domain-shear/attribute_domain_shear.py
index 3cbcb102..72b7587e 100644
--- a/examples/attribute-domain-shear/attribute_domain_shear.py
+++ b/examples/attribute-domain-shear/attribute_domain_shear.py
@@ -216,26 +216,37 @@ def make_material(name, rgb, rough=0.45, metallic=0.35, emit=None, estr=0.0):
     return mat
 
 
+STAND_TILT = math.radians(12)
+STEM_BURY = 0.02
+
+
 def _pinwheel_obj(sc, name, me, loc, rot_z):
     ob = bpy.data.objects.new(name, me)
     ob.location = loc
-    ob.rotation_euler = (math.radians(12), 0.0, rot_z)
+    ob.rotation_euler = (STAND_TILT, 0.0, rot_z)
     sc.collection.objects.link(ob)
-    # stem + hub cap: a garden pinwheel on a stick, not a floating disc
+    # stem + hub cap: a garden pinwheel on a stick, not a floating disc. The
+    # stick runs from just under the floor to the hub it carries, both ends
+    # derived from the stand's own tilt; it used to stop 0.6 below the hub,
+    # hidden under the canopy, holding nothing.
+    stem_lo = -(loc[2] / math.cos(STAND_TILT)) - STEM_BURY
+    stem_hi = HUB_Z
     stem_me = bpy.data.meshes.new(name + "Stem")
     bm = bmesh.new()
     try:
-        bmesh.ops.create_cone(bm, cap_ends=True, segments=10, radius1=0.05,
-                              radius2=0.06, depth=1.35)
-        bmesh.ops.translate(bm, vec=(0.0, 0.0, -0.72), verts=bm.verts)
+        bmesh.ops.create_cone(bm, cap_ends=True, segments=10, radius1=0.045,
+                              radius2=0.035, depth=stem_hi - stem_lo)
+        bmesh.ops.translate(bm, vec=(0.0, 0.0, 0.5 * (stem_lo + stem_hi)),
+                            verts=bm.verts)
         bm.to_mesh(stem_me)
     finally:
         bm.free()
-    stem_me.materials.append(make_material("StemMetal", (0.16, 0.17, 0.18),
-                                           rough=0.4, metallic=0.8))
+    # a painted wooden dowel: near-black steel vanished into the dark stage
+    stem_me.materials.append(make_material("StemDowel", (0.46, 0.30, 0.16),
+                                           rough=0.55, metallic=0.0))
     stem = bpy.data.objects.new(name + "Stem", stem_me)
     stem.location = loc
-    stem.rotation_euler = (math.radians(12), 0.0, rot_z)
+    stem.rotation_euler = (STAND_TILT, 0.0, rot_z)
     sc.collection.objects.link(stem)
     cap_me = bpy.data.meshes.new(name + "Cap")
     bm = bmesh.new()
@@ -249,7 +260,7 @@ def _pinwheel_obj(sc, name, me, loc, rot_z):
                                           rough=0.35, metallic=0.85))
     cap = bpy.data.objects.new(name + "Cap", cap_me)
     cap.location = loc
-    cap.rotation_euler = (math.radians(12), 0.0, rot_z)
+    cap.rotation_euler = (STAND_TILT, 0.0, rot_z)
     sc.collection.objects.link(cap)
     return ob
 
@@ -308,6 +319,9 @@ def light(name, loc, energy, size, col, rot):
     return floor, wall
 
 
+PAIR_X = 1.36
+
+
 def render_still(path, engine):
     """Dual pinwheel: CORNER (crisp petals to the hub) vs naive POINT (last
     write smears the shared hub + ring verts). Colors come from the same
@@ -319,20 +333,22 @@ def render_still(path, engine):
     me_c = build_fan()
     assign_corner(me_c, pal)
     me_c.materials.append(make_attr_material("MatCorner", ATTR_C))
-    left = _pinwheel_obj(sc, "Corner", me_c, (-1.15, 0.0, 1.35), math.radians(-8))
+    # Spread so the two canopies read as two objects: at +/-1.15 their
+    # tips met at x=0 and the pair read as one shape.
+    left = _pinwheel_obj(sc, "Corner", me_c, (-PAIR_X, 0.0, 1.35), math.radians(-8))
 
     me_p = build_fan()
     assign_point_naive(me_p, pal)
     me_p.materials.append(make_attr_material("MatPoint", ATTR_P))
-    right = _pinwheel_obj(sc, "Point", me_p, (1.15, 0.0, 1.35), math.radians(8))
+    right = _pinwheel_obj(sc, "Point", me_p, (PAIR_X, 0.0, 1.35), math.radians(8))
 
-    p_corner = placard(sc, "CORNER", (-1.15, -1.05, 0.02), size=0.13)
-    p_point = placard(sc, "POINT — last write wins", (1.15, -1.05, 0.02), size=0.10)
+    p_corner = placard(sc, "CORNER", (-PAIR_X, -1.05, 0.02), size=0.13)
+    p_point = placard(sc, "POINT — last write wins", (PAIR_X, -1.05, 0.02), size=0.10)
 
     floor, wall = build_studio(sc)
 
     cam_data = bpy.data.cameras.new("Cam")
-    cam_data.lens = 48.0
+    cam_data.lens = 44.0
     cam = bpy.data.objects.new("Cam", cam_data)
     cam.location = (0.0, -6.4, 4.6)
     sc.collection.objects.link(cam)
diff --git a/examples/attribute-domain-shear/preview.webp b/examples/attribute-domain-shear/preview.webp
index 75c828d8..b456702b 100644
Binary files a/examples/attribute-domain-shear/preview.webp and b/examples/attribute-domain-shear/preview.webp differ
diff --git a/examples/gallery.json b/examples/gallery.json
index 42a18977..dd0274b6 100644
--- a/examples/gallery.json
+++ b/examples/gallery.json
@@ -544,7 +544,7 @@
       "name": "attribute-domain-shear",
       "dir": "examples/attribute-domain-shear",
       "teaches": "POINT vs CORNER color-attribute domains on a shared-vertex pinwheel: CORNER stays exact per face while a naive per-wedge POINT loop shears to the last write at the hub. Crisp petals versus a smeared swirl in one frame; the measured shear equals the palette closed form.",
-      "alt": "Two octagonal rainbow-coloured caps labelled CORNER and POINT, last write wins, showing different colour blending.",
+      "alt": "Two rainbow pinwheels on wooden sticks, well apart: CORNER on the left with crisp coloured petals, POINT, last write wins, on the right with colours smeared across the hub.",
       "witnessesFix": "Authoring per-face colors into a POINT-domain attribute overwrites shared vertices once per neighbor; the last write wins and intended colors shear across every shared vertex.",
       "hero": "docs/gallery/assets/attribute-domain-shear-hero.webp",
       "preview": "examples/attribute-domain-shear/preview.webp",
diff --git a/showcase/README.md b/showcase/README.md
index c3177ce4..971a0736 100644
--- a/showcase/README.md
+++ b/showcase/README.md
@@ -584,6 +584,51 @@ entry in `showcase/gallery.json`, and a rendered still.
   as a single casting. Drive a per-shell tone (`PlankTone`) and, for
   wood, grain along each shell's long axis (`GrainDir`) from face
   attributes, seeded so the render is the same every run.
+- **One connected assembly (exit 18, file-local).** Every joint in a
+  piece is a bite, so joined members' surfaces cross. Build a BVH per
+  shell, union the shells whose trees overlap, and assert **one**
+  component. Per-part budgets pass a box resting a hair above its rails,
+  because every plank still touches a wall. The contact graph shows the
+  box as a second component. `cart`'s `--lift-bed` raises planks, walls
+  and straps 7 mm and splits the graph in two.
+- **A z-fight budget matches planes, not centres (exit 15).** A test that
+  counts only faces whose centres coincide within 0.1 mm never fires on a
+  real overlap. `grindstone` reported 0 for a whole release while its iron
+  shoes, exactly as wide as the sill and flush with its end, shared three
+  planes with every sill (a lit slit in each foot close-up). Use the
+  cross-shell coplanar budget above, with a KD-tree range query at
+  `COPLANAR_CENTRE_MAX` so it stays linear on a 5k-triangle piece. A shoe,
+  cap or ferrule is a cup a named reveal proud of its host on every side;
+  `--flush-shoes` restores the flush shoe.
+- **Braces that meet tenon into the host's faces (exit 15).** Two
+  diagonals run to the same centre line meet at one apex. Their chamfered
+  end faces then land on each other inside the host: 6 coplanar pairs on
+  `grindstone`, hidden in the bearing block. End each one a named bite
+  inside the king post's face.
+- **Carried parts bite their bearers (exit 18).** A tub, bed or shelf
+  asserts how deep it bites each member that carries it, as a band, with
+  the bearers counted. Stretchers left at sill height stopped 6 mm under
+  `grindstone`'s trough, a dark slit that the sill seat and the dip band
+  both passed. `--low-stretchers` restores them.
+- **Chamfer n-gon caps, then triangulate.** A triangle-fan cap on a
+  lathe, chamfered 5 mm at its rim, folded its centre out through the cap:
+  8 non-manifold edges per nave on `cart`. An L-strap cap pre-split on its
+  inner-corner diagonal left 24 per strap once the reflex corner was
+  chamfered. Build caps as single n-gons, run the bevel passes, then
+  `bmesh.ops.triangulate` every face over four corners, so the shipped
+  mesh still has no n-gon.
+- **The bake cage is narrower than the nearest neighbour.** `cage_extrusion`
+  only has to cover the difference between high and low, under 2 mm for
+  a chamfer. At 0.08 m, `cart`'s cage reached past the 74 mm between a
+  side wall and its wheel. Rays from the wall hit the high-poly felloe,
+  and the rim baked onto the board as a black staircase that no budget
+  measures. Raising the bake resolution made it sharper, not smaller.
+  Start from 0.01 m and look at the hero.
+- **Aim an edge falsifier at one member.** Skipping a whole chamfer pass
+  moves the triangle count by hundreds: `cart`'s whole-iron skip dropped
+  1200 and exited 4 on the triangle floor. Leave one small member square
+  instead (`--sharp-bar`, `--sharp-handle`, 20–24 right-angle edges and
+  about 48 triangles), so only the edge budget can see it.
 - **Rendered still and gallery entry.** Showcase pieces are visual by
   definition. The pathology / sidecar exemption does not apply. Call
   `examples/gallery_framing.check_framing` on the `--output` path only.
diff --git a/showcase/cart/README.md b/showcase/cart/README.md
index a4e7db31..af51a5bf 100644
--- a/showcase/cart/README.md
+++ b/showcase/cart/README.md
@@ -1,9 +1,18 @@
 # Cart
 
-A showcase piece, not an example. Procedural two-wheel wooden cart
-(slatted bed, side walls, shafts, spoked wheels, iron hubs and axle)
-then the shipped pipeline: unique-cell UVs, Cycles high-to-low normal
-bake, LOD chain, convex collider, Unity glTF export.
+A showcase piece, not an example. A procedural two-wheel handcart built
+on two rails that run on past the bed as shafts, with a pull bar through
+their tips and two prop legs under them. It has a planked floor, board
+walls with iron corner straps, and spoked wheels on long naves with iron
+bands, tyres and washers. The piece then runs the shipped pipeline:
+unique-cell UVs, a Cycles high-to-low normal bake, an LOD chain, a convex
+collider, and a Unity glTF export.
+
+The chassis is stacked from the axle up, and every member bites the one
+below it by a named depth: axle, bolster, rails, floor planks, walls. The
+cart stands level on four named supports: two tyres and two legs.
+Stated size is 1.58 m long, 0.84 m across the axle ends and 0.64 m tall.
+The wheels are 0.64 m in diameter and the bed is 0.92 × 0.50 m.
 
 It asserts **budget conformance** of the generated result. It does not
 witness an API contract. "It rendered without error" is not a check.
@@ -21,60 +30,93 @@ materials, UVs, evaluated LOD, collider, or export file.
 
 | Axis | Declared | Measured (4.5.11 / 5.1.2 / 5.2.1) |
 | --- | --- | --- |
-| Base triangles | 2760–2960 | 2856 / 2856 / 2856 |
+| Base triangles | 5160–5410 | 5284 / 5284 / 5284 |
 | LOD1 ratio | 0.32–0.62 of base | 0.5000 / 0.5000 / 0.5000 |
-| LOD2 ratio | 0.10–0.35 of base | 0.2199 / 0.2199 / 0.2157 |
-| Materials | exactly 2 distinct, metal ≥ 24, wood ≥ 800 faces | 2 slots, floors met |
+| LOD2 ratio | 0.10–0.35 of base | 0.2199 / 0.2199 / 0.2146 |
+| Materials | exactly 2 distinct, metal ≥ 800, wood ≥ 1200 faces | 2 slots; 1196 metal, 1694 wood |
 | UVs | in `0..1`, AABB overlap ≤ 1e-5 | in range, overlap 0 |
-| Outer AABB | (1.539, 0.749, 0.640) m ± 0.01 | (1.5393, 0.7486, 0.6400) |
-| Grounded | bbox min Z within 1e-4 of 0 | 0.0000 / 0.0000 / 0.0000 |
-| Named supports | each tyre's own zmin within 1e-4 of the floor | +Y 0.000000, −Y 0.000000 |
-| Hygiene | loose V/E, non-manifold, zero-area, doubles @1e-5, n-gons: all 0 | 0 / 0 / 0 on every axis |
-| Z-fighting | coplanar cross-shell face pairs = 0 | 0 / 0 / 0 |
+| Outer AABB | (1.580, 0.842, 0.640) m ± 0.01 | (1.5800, 0.8420, 0.6400) |
+| Collider tris | ≤ 360 | 192 |
+| Bake texels | smallest UV cell ≥ 12 px at the baked resolution | 17.45 px at 1024 px |
+| Export | written, size > 0, removed after measuring | 403176 / 403176 / 403160 bytes |
+
+### Hygiene, supports and joints
+
+Recomputed from the generated mesh on all three binaries, identical on
+each.
+
+| Axis | Declared | Measured |
+| --- | --- | --- |
+| Loose V/E, non-manifold, zero-area, doubles @1e-5, n-gons | all 0 | all 0 |
+| Z-fighting | coplanar cross-shell face pairs = 0 | 0 |
+| Grounded | bbox min Z within 1e-4 of 0 | 0.0000 |
+| Named supports | 2 legs found; each tyre and leg zmin within 1e-4 of the floor | 2 legs; all four 0.000000 |
+| Material-island gap | metal↔wood min distance ≤ 0.008 m | 0.00023 |
+| Wall boards | 2 boards per side wall, seams 0.0015–0.005 m | (2, 2), seams 0.00300 |
 | Tyre seat | 0.0030–0.0055 m interference, per angular station | [0.00400, 0.00400] over 48 stations |
+| One assembly | the shells' BVH-overlap graph is 1 component | 1 component, 59 shells |
 | Wheel mirror | the two wheels match in X, Z and extent within 5e-5 m | 0.00000 mm |
-| Material-island gap | metal↔wood min distance ≤ 0.008 m | 0.00000 / 0.00000 / 0.00000 |
-| Collider tris | ≤ 360 | 154 |
-| Export | written, size > 0, removed after measuring | 221960 bytes on 5.2.1 |
+| Edge treatment | manifold edges within 5° of 90° = 0 | 0 wood, 0 iron |
 
-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
+DECIMATE COLLAPSE triangle counts are **not** identical across series.
+5.2.1 is more aggressive on LOD2, so 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.
+operator `FINISHED` plus the texel floor, not byte-identity. Per-board
+tone comes from `random.Random(TONE_SEED)`, so it is identical run to run.
 Export byte counts differ by a few bytes across series (glTF
-serializer); the gate is "written and non-empty", not a byte count, and
+serializer). The gate is "written and non-empty", not a byte count, and
 the file is removed once measured.
 
+The bake cage is 0.01 m: it only has to cover the chamfer difference
+between the 3-segment high and the 1-segment low. At 0.08 m it reached
+past the 74 mm between a side wall and its wheel, so rays from the wall
+hit the high-poly felloe. The wheel's rim baked onto the board as a black
+staircase.
+
 ## Falsifiers
 
 Each flag breaks one stage so a **named** budget fails and the piece
 exits *that* code. Magnitudes are sized so no earlier gate can steal the
-failure: the two wheel moves stay inside `BBOX_TOL`, so the AABB gate
-(exit 8) still passes.
+failure. The wheel, leg and bed moves stay inside `BBOX_TOL`, so the AABB
+gate (exit 8) still passes, and no flag changes the triangle count by
+more than the band allows.
 
 | Flag | Target budget | Exit |
 | --- | --- | --- |
 | `--skip-decimate` | LOD1 ratio band (ratio becomes 1.0) | 9 |
+| `--flush-tyre` | Coplanar cross-shell pairs: sets the tyre's inner radius equal to the felloe's outer radius, which is the construction bug this piece was rebuilt to remove (0 → 144 pairs) | 15 |
 | `--lift-z` | AABB grounded zmin (whole mesh up 0.05 m) | 16 |
-| `--flush-tyre` | Coplanar cross-shell pairs — sets the tyre's inner radius equal to the felloe's outer radius, which is the construction bug this piece was rebuilt to remove (0 → 48 pairs) | 15 |
-| `--sink-tyre` | Tyre seat band — buries the hoop 9 mm into the felloe so it reads as one body | 18 |
-| `--float-wheel` | Named supports — lifts one wheel 3 mm while the other still grounds the AABB | 16 |
-| `--skew-wheel` | Wheel mirror — pushes one wheel 6 mm out along the track | 19 |
-
-`--lift-z` and `--float-wheel` share exit 16 and fail different budgets:
-`--lift-z` fails the AABB gate, which fires first; `--float-wheel` leaves
-the AABB grounded, so only the per-tyre support check can catch it.
+| `--float-wheel` | Named supports: lifts one wheel 3 mm while the other still grounds the AABB | 16 |
+| `--short-props` | Named supports: stops both prop legs 3 mm above the floor while the tyres still ground the AABB | 16 |
+| `--wide-seams` | Wall board seams: opens every seam to 10 mm, same triangle count | 17 |
+| `--sink-tyre` | Tyre seat band: buries the hoop 9 mm into the felloe so it reads as one body | 18 |
+| `--lift-bed` | One assembly: raises the box (planks, walls, straps) 7 mm off its rails, so the contact graph splits in two | 18 |
+| `--skew-wheel` | Wheel mirror: pushes one wheel 6 mm out along the track | 19 |
+| `--sharp-bar` | Edge treatment: leaves the pull bar's rims unchamfered (24 right-angle edges, 48 triangles short) | 20 |
+| `--low-bake` | Bake texel density: bakes at 256 px (4.36 px per cell) | 21 |
+
+`--lift-z`, `--float-wheel` and `--short-props` share exit 16 and fail
+different budgets. `--lift-z` fails the AABB gate, which fires first. The
+other two leave the AABB grounded, so only the per-support check can catch
+them. `--sharp-bar` replaced a flag that skipped the whole iron chamfer
+pass. That flag dropped 1200 triangles and tripped the triangle floor
+(exit 4) instead of the edge budget.
 
 ## Run
 
 ```bash
 blender --background --python cart.py --
 blender --background --python cart.py -- --skip-decimate
-blender --background --python cart.py -- --lift-z
 blender --background --python cart.py -- --flush-tyre
-blender --background --python cart.py -- --sink-tyre
+blender --background --python cart.py -- --lift-z
 blender --background --python cart.py -- --float-wheel
+blender --background --python cart.py -- --short-props
+blender --background --python cart.py -- --wide-seams
+blender --background --python cart.py -- --sink-tyre
+blender --background --python cart.py -- --lift-bed
 blender --background --python cart.py -- --skew-wheel
+blender --background --python cart.py -- --sharp-bar
+blender --background --python cart.py -- --low-bake
 blender --background --python cart.py -- --output cart.png
 ```
 
@@ -90,9 +132,9 @@ File-local. `9` is a valid check code. `10` is reserved for
 | 0 | Success |
 | 1 | Uncaught exception (FATAL wrapper) |
 | 2 | argparse / usage |
-| 3 | Mesh did not build / no UV layer |
+| 3 | Mesh did not build / no UV layer / wheels not found |
 | 4 | Base triangle count outside range |
-| 5 | Material count ≠ 2 distinct slots, or metal faces missing |
+| 5 | Material count ≠ 2 distinct slots, or a face-count floor missed |
 | 6 | UVs outside 0..1 |
 | 7 | UV AABB overlap above tolerance |
 | 8 | World AABB off declared outer size |
@@ -103,7 +145,9 @@ File-local. `9` is a valid check code. `10` is reserved for
 | 13 | Export file missing or empty |
 | 14 | `--output` produced no file |
 | 15 | Hygiene: loose geometry, non-manifold, zero-area, doubles, n-gons, or coplanar cross-shell face pairs (`--flush-tyre` lands here) |
-| 16 | Bbox min Z not grounded (`--lift-z`), or a named support off the floor (`--float-wheel`) |
-| 17 | Material-island gap above tolerance (parts meant to touch) |
-| 18 | Tyre seat depth outside its band (`--sink-tyre` lands here) |
+| 16 | Bbox min Z not grounded (`--lift-z`), or a named support off the floor (`--float-wheel`, `--short-props`) |
+| 17 | Material-island gap above tolerance, or wall boards miscounted or their seams out of band (`--wide-seams`) |
+| 18 | Tyre seat depth outside its band (`--sink-tyre`), or the shells not one connected assembly (`--lift-bed`) |
 | 19 | Wheel mirror deviation above epsilon (`--skew-wheel` lands here) |
+| 20 | A right-angle edge survived the chamfer passes (`--sharp-bar` lands here) |
+| 21 | Bake texel density below the floor (`--low-bake` lands here) |
diff --git a/showcase/cart/cart.py b/showcase/cart/cart.py
index 7cc134a8..f156d877 100644
--- a/showcase/cart/cart.py
+++ b/showcase/cart/cart.py
@@ -1,23 +1,29 @@
-"""Game-ready two-wheel wooden cart — a showcase piece, not an example.
+"""Game-ready two-wheel handcart — a showcase piece, not an example.
 
-Asserts budget conformance of a procedural cart (staved bed, side
-walls, shafts, spoked wheels, iron hubs and axle) 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 handcart (planked bed on two
+rails that run on as shafts, board walls with iron corner straps, prop
+legs, spoked wheels on long naves, iron tyres, axle and washers) after
+composing shipped pipeline pieces: bmesh construction, UVs, two
+materials, high-to-low normal bake, LOD chain, convex collider, Unity
+glTF export.
 
 Budgets are declared below and recomputed from the generated result.
 They are not API-contract witnesses. Each falsifier flag breaks one
 stage so a named budget fails and the piece exits that budget's code:
-``--skip-decimate`` (LOD ratio, 9), ``--lift-z`` (AABB grounded, 16),
-``--float-wheel`` (named supports, 16), ``--flush-tyre`` (coplanar
-cross-shell pairs, 15), ``--sink-tyre`` (tyre seat band, 18),
-``--skew-wheel`` (wheel mirror, 19). The two wheel moves stay inside
-``BBOX_TOL`` so the AABB gate cannot steal the failure.
-
-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.
+``--skip-decimate`` (LOD ratio, 9), ``--flush-tyre`` (coplanar
+cross-shell pairs, 15), ``--lift-z`` (AABB grounded, 16),
+``--float-wheel`` and ``--short-props`` (named supports, 16),
+``--wide-seams`` (wall board seams, 17), ``--sink-tyre`` (tyre seat
+band, 18), ``--lift-bed`` (one connected assembly, 18), ``--skew-wheel``
+(wheel mirror, 19), ``--sharp-bar`` (edge treatment, 20), ``--low-bake``
+(bake texel density, 21). The wheel,
+leg and bed moves stay inside ``BBOX_TOL`` so the AABB gate cannot steal
+the failure.
+
+Seeded, not random: per-board tone uses ``random.Random(TONE_SEED)``.
+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.
 
     blender --background --python cart.py --
     blender --background --python cart.py -- --skip-decimate
@@ -27,6 +33,7 @@
 import argparse
 import math
 import os
+import random
 import sys
 import tempfile
 import traceback
@@ -35,6 +42,7 @@
 import bpy
 from mathutils import Euler, Vector
 from mathutils.bvhtree import BVHTree
+from mathutils.kdtree import KDTree
 
 _REPO = os.path.abspath(
     os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir, os.pardir)
@@ -43,10 +51,12 @@
 sys.dont_write_bytecode = True
 import gallery_framing  # noqa: E402
 
-RIM_MAJOR = 0.30
-# Felloe ring: flat-tread box section, not a round tube — round torus rims
-# read as bicycle wheels. The iron tyre wraps the tread.
-RIM_RADIAL = 0.012
+RIM_OUTER = 0.312
+# Felloe: flat-tread box section, not a round tube — round torus rims read
+# as bicycle wheels. RIM_RADIAL is the half-depth: a 40 mm felloe. The
+# first build's 24 mm read as a bent strip at hero size.
+RIM_RADIAL = 0.020
+RIM_MAJOR = RIM_OUTER - RIM_RADIAL
 RIM_W = 0.036
 TYRE_T = 0.008
 TYRE_W = 0.040
@@ -55,38 +65,109 @@
 # set equal to it: r_in == r_out puts the tyre's inner cylinder and the
 # felloe's tread on one plane for every segment, which is a guaranteed
 # z-fight (it measured 32 coplanar cross-shell pairs, 16 per wheel).
-RIM_OUTER = RIM_MAJOR + RIM_RADIAL
 TYRE_SEAT = 0.004
 TYRE_SEAT_MIN = 0.0030
 TYRE_SEAT_MAX = 0.0055
+WHEEL_R = RIM_OUTER + TYRE_T
 WHEEL_SEGMENTS = 24
 TRACK = 0.68
-AXLE_X = -0.16
 AXLE_R = 0.020
-HUB_R = 0.052
-HUB_W = 0.046
-N_SPOKES = 8
-SPOKE_T = 0.018
+# The axle runs past each washer, so a washer pushed out by --skew-wheel
+# still stops short of the axle's end cap instead of landing on its plane.
+AXLE_PROUD = 0.016
+# A nave is a long barrel, not a disc. The first build's 46 mm hub read as
+# a toy wheel in every view; 130 mm with an iron band at each end is a
+# cartwheel's proportion.
+NAVE_L = 0.130
+NAVE_R_END = 0.044
+NAVE_R_MID = 0.058
+NAVE_BAND_ZONE = 0.028
+NAVE_BAND_W = 0.016
+NAVE_BAND_T = 0.006
+NAVE_BAND_BITE = 0.002
+NAVE_SEGS = 12
+WASHER_R = 0.032
+WASHER_BITE = 0.003
+WASHER_T = 0.009
+N_SPOKES = 10
+SPOKE_W = 0.022
+SPOKE_D = 0.018
+SPOKE_ROOT = 0.020
+SPOKE_TENON = 0.014
+
+# Chassis, stacked from the axle up. Each member bites the one below it by
+# a named depth, so nothing rests on a tangent line or floats.
 BED_L = 0.92
 BED_W = 0.50
-BED_T = 0.038
-WALL_H = 0.16
-WALL_T = 0.032
-TAILGATE_H = 0.10
-SHAFT_L = 0.58
-SHAFT_T = 0.034
-SHAFT_PITCH = math.radians(7.0)
-N_SLATS = 6
-IRON_T = 0.014
+BED_CX = 0.06
+AXLE_X = BED_CX - 0.22
+AXLE_BITE = 0.006
 BOLSTER_H = 0.044
+BOLSTER_X = 0.060
+BOLSTER_SPAN = 0.52
+RAIL_Y = 0.17
+RAIL_W = 0.040
+RAIL_H = 0.050
+RAIL_BITE = 0.006
+RAIL_BACK = 0.03
+FLOOR_T = 0.030
+N_FLOOR = 9
+FLOOR_GAP = 0.004
+FLOOR_BITE = 0.004
+# Walls stand on the floor, inset from its edge. The first build hung them
+# outside the planks at mid-thickness, which left every slat end poking out
+# under the front board as a row of teeth; flush with the plank ends they
+# would share the end grain's plane.
+WALL_H = 0.18
+WALL_T = 0.028
+WALL_SEAT = 0.006
+WALL_INSET = 0.004
+WALL_BOARDS = 2
+WALL_SEAM = 0.003
+WALL_SEAM_MIN = 0.0015
+WALL_SEAM_MAX = 0.005
+WIDE_SEAM = 0.010
+# End boards sit between the side walls: recessed, seated deeper, split at
+# a different height and topped lower, so no face of an end board lands on
+# a plane of a side board.
+END_INSET = 0.003
+END_BITE = 0.012
+END_SEAT = 0.009
+END_SPLIT = 0.46
+END_DROP = 0.008
+TAILGATE_H = 0.100
+SHAFT_L = 0.58
+HANDLE_R = 0.017
+HANDLE_BACK = 0.07
+HANDLE_PROUD = 0.012
+# The first build hovered its shaft tips 0.30 m off the floor with the
+# centre of mass ahead of the axle: it would tip. Two prop legs under the
+# rails stand it level. Thinner than the rail, so their faces never share
+# its planes.
+LEG_T = 0.034
+LEG_BACK = 0.09
+LEG_BITE = 0.024
+SHORT_PROP_Z = 0.003
+# Iron corner straps: one L-section shell per corner, bitten into both
+# faces of the side wall it is nailed to.
+STRAP_LEG = 0.050
+STRAP_T = 0.004
+STRAP_BITE = 0.0015
+STRAP_MARGIN = 0.012
+IRON_BEVEL = 0.0012
+BEVEL_MIN_ANGLE = math.radians(50.0)
+PLANK_TONE_JITTER = 0.28
+TONE_SEED = 31
+WOOD_GRAIN_SCALE = 30.0
 
 BBOX_TOL = 0.01
-OUTER_SIZE = (1.539, 0.749, 0.640)
-# Re-fitted after the wheel went from 16 to 24 segments (2600 -> 2856).
-# Narrower than the band it replaces (200 wide, was 430) and centred on
-# the measured value, so this is a tightening, not a widening.
-BASE_TRIS_MIN = 2760
-BASE_TRIS_MAX = 2960
+# Rails run on as shafts past the bed (X); axle ends past the washers (Y);
+# the tyre tops (Z). Re-declared for the rebuild: 1.539 x 0.749 before.
+OUTER_SIZE = (1.580, 0.842, 0.640)
+# Re-fitted for the rebuild (2856 -> 5284: naves, bands, washers, straps,
+# legs, boards). Centred on the measurement, 250 wide against the old 200.
+BASE_TRIS_MIN = 5160
+BASE_TRIS_MAX = 5410
 ZMIN_EPS = 1e-4
 DOUBLES_EPS = 1e-5
 AREA_EPS = 1e-10
@@ -102,10 +183,20 @@
 UV_EPS = 1e-4
 UV_OVERLAP_MAX = 1e-5
 COLLIDER_TRIS_MAX = 360
-BAKE_RES = 256
-CAGE_EXTRUSION = 0.08
-METAL_FACES_MIN = 24
-WOOD_FACES_MIN = 800
+# One UV cell per face: at 256 px each of the ~2900 faces got about 4 px,
+# and the render's bilinear lookup read neighbouring cells' normals as a
+# black hexagon and sandpaper speckle on the side boards (tavern-stool's
+# defect). 1024 px gives every cell 17 px against a 12 px floor.
+BAKE_RES = 1024
+LOW_BAKE_RES = 256
+TEXEL_MIN = 12.0
+# The cage only has to cover the chamfer difference between the 3-segment
+# high and the 1-segment low (under 2 mm). At 0.08 it reached past the
+# 74 mm between side wall and felloe, so rays from the wall hit the high
+# wheel and baked its rim onto the board as a black staircase.
+CAGE_EXTRUSION = 0.01
+METAL_FACES_MIN = 800
+WOOD_FACES_MIN = 1200
 
 # Z-fighting: two separate bodies landing on one plane. Cross-shell, with
 # hay-bale's constants (copied, not imported).
@@ -113,11 +204,21 @@
 COPLANAR_PLANE_EPS = 1e-4
 COPLANAR_CENTRE_MAX = 0.05
 ZFIGHT_PAIRS_MAX = 0
-# Named supports: a two-wheel cart's AABB zmin is grounded by whichever
-# tyre happens to be lowest. Each tyre carries its own floor contact.
+# Named supports: two tyres and two prop legs. The AABB zmin is grounded by
+# whichever of them is lowest, so each carries its own floor contact.
 SUPPORT_ZMIN_EPS = 1e-4
+N_LEGS = 2
 # Mirrored members: the two wheels are the same part reflected in Y.
 WHEEL_MIRROR_EPS = 5e-5
+# Every member is joined to the rest: the BVH-overlap graph of the shells
+# is one component. A bed resting a hair above its rails passes every
+# per-part budget and is still a floating box.
+CONTACT_COMPONENTS = 1
+LIFT_BED = FLOOR_BITE + 0.003
+# Edge treatment: every edge is chamfered, so a manifold edge still within
+# RIGHT_ANGLE_TOL of 90 degrees is one a bevel pass skipped.
+RIGHT_ANGLE_TOL = math.radians(5.0)
+RIGHT_ANGLE_MAX = 0
 # Falsifier magnitudes, each sized to trip its own budget and nothing
 # earlier: the wheel moves stay inside BBOX_TOL so the AABB gate cannot
 # steal the failure.
@@ -161,6 +262,12 @@ def deselect_all():
         ob.select_set(False)
 
 
+def _faces_of(verts, mat_idx):
+    faces = {f for v in verts for f in v.link_faces}
+    for f in faces:
+        f.material_index = mat_idx
+
+
 def add_box(bm, loc, scale, mat_idx, euler=(0.0, 0.0, 0.0)):
     geo = bmesh.ops.create_cube(bm, size=1.0)
     verts = geo["verts"]
@@ -169,12 +276,37 @@ def add_box(bm, loc, scale, mat_idx, euler=(0.0, 0.0, 0.0)):
     for v in verts:
         p = Vector((v.co.x * scale[0], v.co.y * scale[1], v.co.z * scale[2]))
         v.co = rot @ p + origin
-    faces = {f for v in verts for f in v.link_faces}
-    for f in faces:
-        f.material_index = mat_idx
+    _faces_of(verts, mat_idx)
     return verts
 
 
+def add_span(bm, lo, hi, mat_idx):
+    """Axis-aligned box from its min corner to its max corner."""
+    lo = Vector(lo)
+    hi = Vector(hi)
+    return add_box(bm, (lo + hi) * 0.5, hi - lo, mat_idx)
+
+
+def add_oriented_box(bm, a, b, scale_xy, mat_idx):
+    """Box whose long axis runs from station ``a`` to station ``b``.
+
+    For a direction in the XZ plane the rotation is about Y alone, so the
+    box's local Y stays world Y — a spoke's thin side stays along the axle.
+    """
+    a = Vector(a)
+    b = Vector(b)
+    delta = b - a
+    length = delta.length
+    if length < 1e-8:
+        return []
+    quat = Vector((0.0, 0.0, 1.0)).rotation_difference(delta.normalized())
+    eul = quat.to_euler("XYZ")
+    return add_box(
+        bm, (a + b) * 0.5, (scale_xy[0], scale_xy[1], length), mat_idx,
+        euler=(eul.x, eul.y, eul.z),
+    )
+
+
 def add_cyl(bm, loc, radius, depth, segments, mat_idx, euler=(0.0, 0.0, 0.0)):
     geo = bmesh.ops.create_cone(
         bm,
@@ -190,21 +322,19 @@ def add_cyl(bm, loc, radius, depth, segments, mat_idx, euler=(0.0, 0.0, 0.0)):
     origin = Vector(loc)
     for v in verts:
         v.co = rot @ v.co + origin
-    faces = {f for v in verts for f in v.link_faces}
-    for f in faces:
-        f.material_index = mat_idx
+    _faces_of(verts, mat_idx)
     return verts
 
 
-def add_ring(bm, loc, r_mid, radial_t, width, segments, mat_idx, euler=(0.0, 0.0, 0.0)):
-    """Flat-sided ring with a box cross-section (felloe / tyre profile).
+def add_ring(bm, loc, r_in, r_out, width, segments, mat_idx):
+    """Flat-sided ring with a box cross-section, its axis along world Y.
 
     Manifold: outer tread, inner surface, and two side annuli, all quads.
-    Built in the XY plane, width along Z, then rotated/translated.
+    Built in the XZ plane with u measured from +X toward +Z, so a segment
+    count divisible by four puts a vertex at the very bottom.
     """
-    r_in = r_mid - radial_t
-    r_out = r_mid + radial_t
     hw = width / 2.0
+    ox, oy, oz = loc
     rings = []
     for i in range(segments):
         u = i * (2.0 * math.pi / segments)
@@ -212,30 +342,95 @@ def add_ring(bm, loc, r_mid, radial_t, width, segments, mat_idx, euler=(0.0, 0.0
         su = math.sin(u)
         rings.append(
             [
-                bm.verts.new((r_in * cu, r_in * su, -hw)),
-                bm.verts.new((r_out * cu, r_out * su, -hw)),
-                bm.verts.new((r_out * cu, r_out * su, hw)),
-                bm.verts.new((r_in * cu, r_in * su, hw)),
+                bm.verts.new((ox + r_in * cu, oy - hw, oz + r_in * su)),
+                bm.verts.new((ox + r_out * cu, oy - hw, oz + r_out * su)),
+                bm.verts.new((ox + r_out * cu, oy + hw, oz + r_out * su)),
+                bm.verts.new((ox + r_in * cu, oy + hw, oz + r_in * su)),
             ]
         )
     for i in range(segments):
-        i2 = (i + 1) % segments
         a = rings[i]
-        b = rings[i2]
+        b = rings[(i + 1) % segments]
         for quad in (
             (a[1], b[1], b[2], a[2]),
             (a[3], b[3], b[0], a[0]),
             (a[2], b[2], b[3], a[3]),
             (a[0], b[0], b[1], a[1]),
         ):
-            face = bm.faces.new(quad)
-            face.material_index = mat_idx
-    verts = [v for ring in rings for v in ring]
-    rot = Euler(euler).to_matrix()
-    origin = Vector(loc)
-    for v in verts:
-        v.co = rot @ v.co + origin
-    return verts
+            bm.faces.new(quad).material_index = mat_idx
+    return [v for ring in rings for v in ring]
+
+
+def add_lathe_y(bm, loc, profile, segments, mat_idx):
+    """Closed solid of revolution about world Y from ``(dy, radius)`` pairs.
+
+    Capped at both ends with an n-gon that ``finish_caps`` triangulates
+    after the chamfer pass: a triangle-fan cap, chamfered 5 mm at its rim,
+    folded its centre out through the cap as non-manifold slivers.
+    """
+    ox, oy, oz = loc
+    rings = []
+    for dy, r in profile:
+        ring = []
+        for i in range(segments):
+            u = 2.0 * math.pi * i / segments
+            ring.append(bm.verts.new(
+                (ox + r * math.cos(u), oy + dy, oz + r * math.sin(u))))
+        rings.append(ring)
+    for a, b in zip(rings, rings[1:]):
+        for k in range(segments):
+            kn = (k + 1) % segments
+            bm.faces.new((a[k], a[kn], b[kn], b[k])).material_index = mat_idx
+    bm.faces.new(list(reversed(rings[0]))).material_index = mat_idx
+    bm.faces.new(rings[-1]).material_index = mat_idx
+    return [v for ring in rings for v in ring]
+
+
+def add_l_strap(bm, corner, sx, sy, z0, z1, mat_idx):
+    """One L-section iron strap wrapped round a vertical box corner.
+
+    ``corner`` is the wood's outer corner in plan; ``sx``/``sy`` point out
+    of the box. Both legs bite ``STRAP_BITE`` into the wood faces. One
+    shell: two overlapping boxes would chamfer a strip onto the same line
+    twice. Each cap is one L n-gon until ``finish_caps`` triangulates it
+    after the chamfer pass; caps pre-split on the inner-corner diagonal
+    left 24 non-manifold edges per strap once the reflex corner was
+    chamfered.
+    """
+    xc, yc = corner
+    b, t, leg = STRAP_BITE, STRAP_T, STRAP_LEG
+    xi, yi = xc - sx * b, yc - sy * b
+    xo, yo = xc + sx * (t - b), yc + sy * (t - b)
+    plan = [
+        (xi, yi),
+        (xi - sx * leg, yi),
+        (xi - sx * leg, yo),
+        (xo, yo),
+        (xo, yi - sy * leg),
+        (xi, yi - sy * leg),
+    ]
+    lo = [bm.verts.new((x, y, z0)) for x, y in plan]
+    hi = [bm.verts.new((x, y, z1)) for x, y in plan]
+    n = len(plan)
+    for k in range(n):
+        kn = (k + 1) % n
+        bm.faces.new((lo[k], lo[kn], hi[kn], hi[k])).material_index = mat_idx
+    bm.faces.new(list(reversed(lo))).material_index = mat_idx
+    bm.faces.new(hi).material_index = mat_idx
+    return lo + hi
+
+
+def finish_caps(bm):
+    """Triangulate every face with more than four corners.
+
+    Lathe and strap caps are built as n-gons so the chamfer pass has clean
+    rims to work on; the shipped mesh carries no n-gon.
+    """
+    ngons = [f for f in bm.faces if len(f.verts) > 4]
+    if ngons:
+        bmesh.ops.triangulate(
+            bm, faces=ngons, quad_method="BEAUTY", ngon_method="BEAUTY",
+        )
 
 
 def pack_uvs(bm, margin=0.08):
@@ -281,216 +476,207 @@ def pack_uvs(bm, margin=0.08):
             )
 
 
+def chassis_levels():
+    """Z of every chassis level, stacked from the axle up by named bites."""
+    axle_z = WHEEL_R
+    bolster_z0 = axle_z + AXLE_R - AXLE_BITE
+    bolster_z1 = bolster_z0 + BOLSTER_H
+    rail_z0 = bolster_z1 - RAIL_BITE
+    rail_z1 = rail_z0 + RAIL_H
+    floor_z0 = rail_z1 - FLOOR_BITE
+    floor_z1 = floor_z0 + FLOOR_T
+    wall_z0 = floor_z1 - WALL_SEAT
+    return {
+        "axle": axle_z, "bolster0": bolster_z0, "bolster1": bolster_z1,
+        "rail0": rail_z0, "rail1": rail_z1, "floor0": floor_z0,
+        "floor1": floor_z1, "wall0": wall_z0, "wall1": wall_z0 + WALL_H,
+    }
+
+
+def board_heights(z0, total, n, seam, split=None):
+    """(bottom, top) of ``n`` boards stacked in ``total`` with ``seam`` gaps."""
+    if n == 1:
+        return [(z0, z0 + total)]
+    usable = total - (n - 1) * seam
+    if split is not None and n == 2:
+        hs = [usable * split, usable * (1.0 - split)]
+    else:
+        hs = [usable / n] * n
+    out = []
+    z = z0
+    for h in hs:
+        out.append((z, z + h))
+        z += h + seam
+    return out
+
+
 def add_wheel(bm, loc, wood, metal):
-    wood.extend(
-        add_ring(
-            bm, loc, RIM_MAJOR, RIM_RADIAL, RIM_W, WHEEL_SEGMENTS, WOOD_IDX,
-            euler=(math.pi / 2.0, 0.0, 0.0),
-        )
-    )
+    ox, oy, oz = loc
+    wood.extend(add_ring(
+        bm, loc, RIM_MAJOR - RIM_RADIAL, RIM_OUTER, RIM_W, WHEEL_SEGMENTS, WOOD_IDX,
+    ))
     # Hooped, not pasted on: inner radius is RIM_OUTER - TYRE_SEAT so the
-    # band bites into the felloe, and the tread still lands at
-    # RIM_OUTER + TYRE_T so the tyre stays the ground contact.
-    tyre_in = RIM_OUTER - TYRE_SEAT
-    tyre_out = RIM_OUTER + TYRE_T
-    metal.extend(
-        add_ring(
-            bm, loc, 0.5 * (tyre_in + tyre_out), 0.5 * (tyre_out - tyre_in),
-            TYRE_W, WHEEL_SEGMENTS, METAL_IDX,
-            euler=(math.pi / 2.0, 0.0, 0.0),
-        )
-    )
-    wood.extend(
-        add_cyl(
-            bm,
-            loc,
-            HUB_R,
-            HUB_W,
-            12,
-            WOOD_IDX,
-            euler=(math.pi / 2.0, 0.0, 0.0),
-        )
-    )
-    # Spokes root inside the hub and embed into the felloe ring — no
-    # floating ends hidden by the hub band.
-    inner = HUB_R * 0.4
-    outer = RIM_MAJOR - RIM_RADIAL + 0.008
-    mid_r = 0.5 * (inner + outer)
-    slen = outer - inner
+    # band bites into the felloe, and the tread still lands at WHEEL_R so
+    # the tyre stays the ground contact.
+    metal.extend(add_ring(
+        bm, loc, RIM_OUTER - TYRE_SEAT, WHEEL_R, TYRE_W, WHEEL_SEGMENTS, METAL_IDX,
+    ))
+    zone = NAVE_BAND_ZONE
+    half = NAVE_L / 2.0
+    wood.extend(add_lathe_y(
+        bm, loc,
+        [(-half, NAVE_R_END), (-half + zone, NAVE_R_END), (0.0, NAVE_R_MID),
+         (half - zone, NAVE_R_END), (half, NAVE_R_END)],
+        NAVE_SEGS, WOOD_IDX,
+    ))
+    for s in (-1.0, 1.0):
+        metal.extend(add_ring(
+            bm, (ox, oy + s * (half - zone / 2.0), oz),
+            NAVE_R_END - NAVE_BAND_BITE, NAVE_R_END + NAVE_BAND_T,
+            NAVE_BAND_W, NAVE_SEGS, METAL_IDX,
+        ))
+    # Outboard washer: bites the nave's end and the axle.
+    out = 1.0 if oy > 0.0 else -1.0
+    w_mid = oy + out * (half - WASHER_BITE + WASHER_T / 2.0)
+    metal.extend(add_ring(
+        bm, (ox, w_mid, oz), AXLE_R - 0.002, WASHER_R, WASHER_T, NAVE_SEGS, METAL_IDX,
+    ))
+    # Spokes root inside the nave and tenon into the felloe.
+    r0 = NAVE_R_MID - SPOKE_ROOT
+    r1 = RIM_MAJOR - RIM_RADIAL + SPOKE_TENON
     for i in range(N_SPOKES):
-        a = i * (2.0 * math.pi / N_SPOKES)
-        dx = math.cos(a)
-        dz = math.sin(a)
-        cx = loc[0] + dx * mid_r
-        cy = loc[1]
-        cz = loc[2] + dz * mid_r
-        wood.extend(
-            add_box(
-                bm,
-                (cx, cy, cz),
-                (slen, SPOKE_T * 0.85, SPOKE_T),
-                WOOD_IDX,
-                euler=(0.0, -a, 0.0),
-            )
-        )
-    metal.extend(
-        add_cyl(
-            bm,
-            loc,
-            HUB_R + 0.010,
-            0.016,
-            12,
-            METAL_IDX,
-            euler=(math.pi / 2.0, 0.0, 0.0),
-        )
-    )
-    metal.extend(
-        add_cyl(
-            bm,
-            (loc[0], loc[1] + (HUB_W * 0.55 if loc[1] > 0 else -HUB_W * 0.55), loc[2]),
-            0.022,
-            0.018,
-            10,
-            METAL_IDX,
-            euler=(math.pi / 2.0, 0.0, 0.0),
-        )
-    )
-
-
-def build_cart_mesh(name, bevel_offset, bevel_segments):
+        a = (i + 0.5) * (2.0 * math.pi / N_SPOKES)
+        d = Vector((math.cos(a), 0.0, math.sin(a)))
+        c = Vector(loc)
+        wood.extend(add_oriented_box(bm, c + d * r0, c + d * r1,
+                                     (SPOKE_W, SPOKE_D), WOOD_IDX))
+
+
+def build_cart_mesh(name, bevel_offset, bevel_segments, sharp_bar=False,
+                    wide_seams=False, short_props=False):
+    lv = chassis_levels()
+    bed_x0 = BED_CX - BED_L / 2.0
+    bed_x1 = BED_CX + BED_L / 2.0
     bm = bmesh.new()
     try:
-        body = []
-        wood_wheels = []
+        wood = []
         metal = []
-        axle_z = RIM_MAJOR
-        # The bed rides on the axle through a bolster: axle top -> bolster ->
-        # bed bottom. Never let the axle interpenetrate the slats.
-        bed_z = axle_z + AXLE_R + BOLSTER_H + BED_T / 2.0
-        bed_bottom = bed_z - BED_T / 2.0
-        bed_cx = 0.06
-
-        add_wheel(bm, (AXLE_X, TRACK / 2.0, axle_z), wood_wheels, metal)
-        add_wheel(bm, (AXLE_X, -TRACK / 2.0, axle_z), wood_wheels, metal)
-
-        metal.extend(
-            add_cyl(
-                bm,
-                (AXLE_X, 0.0, axle_z),
-                AXLE_R,
-                TRACK + 0.06,
-                10,
-                METAL_IDX,
-                euler=(math.pi / 2.0, 0.0, 0.0),
-            )
-        )
+        axle_z = lv["axle"]
+        for s in (1.0, -1.0):
+            add_wheel(bm, (AXLE_X, s * TRACK / 2.0, axle_z), wood, metal)
+        axle_len = TRACK + NAVE_L + 2.0 * AXLE_PROUD
+        metal.extend(add_cyl(
+            bm, (AXLE_X, 0.0, axle_z), AXLE_R, axle_len, 12, METAL_IDX,
+            euler=(math.pi / 2.0, 0.0, 0.0),
+        ))
 
-        slat_w = BED_W / N_SLATS
-        y0 = -BED_W / 2.0 + slat_w / 2.0
-        for i in range(N_SLATS):
-            y = y0 + i * slat_w
-            body.extend(
-                add_box(
-                    bm,
-                    (bed_cx, y, bed_z),
-                    (BED_L, slat_w * 0.88, BED_T),
-                    WOOD_IDX,
-                )
-            )
-        # Side walls and the front board finish flush at WALL_H; the back
-        # board is a deliberately lower tailgate.
-        for ysign in (-1.0, 1.0):
-            body.extend(
-                add_box(
-                    bm,
-                    (bed_cx, ysign * (BED_W / 2.0 + WALL_T / 2.0), bed_z + WALL_H / 2.0),
-                    (BED_L * 0.98, WALL_T, WALL_H),
-                    WOOD_IDX,
-                )
-            )
-        body.extend(
-            add_box(
+        # Bolster notched onto the axle; rails on the bolster.
+        wood.extend(add_span(
+            bm,
+            (AXLE_X - BOLSTER_X / 2.0, -BOLSTER_SPAN / 2.0, lv["bolster0"]),
+            (AXLE_X + BOLSTER_X / 2.0, BOLSTER_SPAN / 2.0, lv["bolster1"]),
+            WOOD_IDX,
+        ))
+        tip_x = bed_x1 + SHAFT_L
+        for s in (-1.0, 1.0):
+            wood.extend(add_span(
                 bm,
-                (bed_cx + BED_L / 2.0 - WALL_T / 2.0, 0.0, bed_z + WALL_H / 2.0),
-                (WALL_T, BED_W + WALL_T * 2.0, WALL_H),
+                (bed_x0 + RAIL_BACK, s * RAIL_Y - RAIL_W / 2.0, lv["rail0"]),
+                (tip_x, s * RAIL_Y + RAIL_W / 2.0, lv["rail1"]),
                 WOOD_IDX,
-            )
-        )
-        body.extend(
-            add_box(
+            ))
+            # Prop leg tenoned into the rail's underside.
+            leg_x = bed_x1 - LEG_BACK
+            foot_z = SHORT_PROP_Z if short_props else 0.0
+            wood.extend(add_span(
                 bm,
-                (bed_cx - BED_L / 2.0 + WALL_T / 2.0, 0.0, bed_z + TAILGATE_H / 2.0),
-                (WALL_T, BED_W + WALL_T * 2.0, TAILGATE_H),
+                (leg_x - LEG_T / 2.0, s * RAIL_Y - LEG_T / 2.0, foot_z),
+                (leg_x + LEG_T / 2.0, s * RAIL_Y + LEG_T / 2.0,
+                 lv["rail0"] + LEG_BITE),
                 WOOD_IDX,
-            )
+            ))
+        # Pulling bar through both shaft tips.
+        bar_half = RAIL_Y + RAIL_W / 2.0 + HANDLE_PROUD
+        bar = set(add_cyl(
+            bm, (tip_x - HANDLE_BACK, 0.0, 0.5 * (lv["rail0"] + lv["rail1"])),
+            HANDLE_R, 2.0 * bar_half, 12, WOOD_IDX,
+            euler=(math.pi / 2.0, 0.0, 0.0),
+        ))
+        wood.extend(bar)
+
+        # Floor: planks across the rails.
+        w = (BED_L - (N_FLOOR - 1) * FLOOR_GAP) / N_FLOOR
+        for i in range(N_FLOOR):
+            x0 = bed_x0 + i * (w + FLOOR_GAP)
+            wood.extend(add_span(
+                bm, (x0, -BED_W / 2.0, lv["floor0"]),
+                (x0 + w, BED_W / 2.0, lv["floor1"]), WOOD_IDX,
+            ))
+
+        # Side walls: stacked boards standing on the floor.
+        seam = WIDE_SEAM if wide_seams else WALL_SEAM
+        yo = BED_W / 2.0 - WALL_INSET
+        xa = bed_x0 + WALL_INSET
+        xb = bed_x1 - WALL_INSET
+        for s in (-1.0, 1.0):
+            for z0, z1 in board_heights(lv["wall0"], WALL_H, WALL_BOARDS, seam):
+                ylo, yhi = sorted((s * yo, s * (yo - WALL_T)))
+                wood.extend(add_span(bm, (xa, ylo, z0), (xb, yhi, z1), WOOD_IDX))
+        # End boards between the side walls, biting into them.
+        e_half = yo - WALL_T + END_BITE
+        e_z0 = lv["floor1"] - END_SEAT
+        front = board_heights(
+            e_z0, lv["wall1"] - END_DROP - e_z0, WALL_BOARDS, seam, split=END_SPLIT,
         )
-        # Bolsters: one sits on the axle, one forward; both carry the bed.
-        for xj in (AXLE_X, bed_cx + BED_L * 0.28):
-            body.extend(
-                add_box(
-                    bm,
-                    (xj, 0.0, axle_z + AXLE_R + BOLSTER_H / 2.0),
-                    (0.055, BED_W * 0.92, BOLSTER_H),
-                    WOOD_IDX,
-                )
-            )
+        tail = board_heights(e_z0, TAILGATE_H, 1, seam)
+        for boards, xs in (
+            (front, (xb - END_INSET - WALL_T, xb - END_INSET)),
+            (tail, (xa + END_INSET, xa + END_INSET + WALL_T)),
+        ):
+            for z0, z1 in boards:
+                wood.extend(add_span(
+                    bm, (xs[0], -e_half, z0), (xs[1], e_half, z1), WOOD_IDX,
+                ))
+
+        # Iron corner straps on the side walls' corners.
+        sz0 = lv["floor1"] + STRAP_MARGIN
+        sz1 = lv["wall1"] - STRAP_MARGIN
+        for cx, sx in ((xb, 1.0), (xa, -1.0)):
+            for sy in (-1.0, 1.0):
+                metal.extend(add_l_strap(bm, (cx, sy * yo), sx, sy, sz0, sz1, METAL_IDX))
+
+        bm.edges.index_update()
+
+        def sharp(edge, idx):
+            if len(edge.link_faces) != 2:
+                return False
+            # --sharp-bar leaves the pull bar's rims square: 48 triangles
+            # short, well inside the triangle band, so only the edge
+            # budget can see it. Skipping the whole iron pass dropped
+            # 1200 and tripped the triangle floor instead.
+            if sharp_bar and all(v in bar for v in edge.verts):
+                return False
+            if any(f.material_index != idx for f in edge.link_faces):
+                return False
+            return edge.calc_face_angle(0.0) > BEVEL_MIN_ANGLE
 
-        # Shafts hang under the bed front: the back end embeds 6 mm into the
-        # slat bottom and never pokes through the bed floor.
-        shaft_x = bed_cx + BED_L / 2.0 + SHAFT_L / 2.0 - 0.04
-        shaft_z = (
-            bed_bottom + 0.006 - SHAFT_T / 2.0
-            - math.sin(SHAFT_PITCH) * (SHAFT_L / 2.0)
-        )
-        for ysign in (-1.0, 1.0):
-            body.extend(
-                add_box(
-                    bm,
-                    (shaft_x, ysign * 0.12, shaft_z),
-                    (SHAFT_L, SHAFT_T, SHAFT_T),
-                    WOOD_IDX,
-                    euler=(0.0, SHAFT_PITCH, 0.0),
-                )
+        if bevel_offset > 0.0:
+            edges = sorted(
+                (e for e in bm.edges if sharp(e, WOOD_IDX)), key=lambda e: e.index
             )
-            metal.extend(
-                add_box(
-                    bm,
-                    (bed_cx + BED_L / 2.0 - 0.02, ysign * 0.12, bed_bottom - IRON_T / 2.0),
-                    (0.05, 0.042, IRON_T),
-                    METAL_IDX,
-                )
+            bmesh.ops.bevel(
+                bm, geom=edges, offset=bevel_offset, segments=bevel_segments,
+                profile=0.5, affect="EDGES", clamp_overlap=True, material=WOOD_IDX,
             )
-
-        # Tie-down plates sit on top of the bed floor, fully inboard of the
-        # walls — visible, not buried inside the slats.
-        for sx, sy in (
-            (bed_cx - BED_L / 2.0 + 0.055, -BED_W / 2.0 + 0.055),
-            (bed_cx - BED_L / 2.0 + 0.055, BED_W / 2.0 - 0.055),
-            (bed_cx + BED_L / 2.0 - 0.055, -BED_W / 2.0 + 0.055),
-            (bed_cx + BED_L / 2.0 - 0.055, BED_W / 2.0 - 0.055),
-        ):
-            metal.extend(
-                add_box(
-                    bm,
-                    (sx, sy, bed_z + BED_T / 2.0 + IRON_T / 2.0),
-                    (0.055, 0.055, IRON_T),
-                    METAL_IDX,
-                )
+            bm.edges.index_update()
+            edges = sorted(
+                (e for e in bm.edges if sharp(e, METAL_IDX)), key=lambda e: e.index
             )
-
-        if bevel_offset > 0.0:
-            edges = list({e for v in body for e in v.link_edges})
-            ret = bmesh.ops.bevel(
-                bm,
-                geom=edges,
-                offset=bevel_offset,
-                segments=bevel_segments,
-                profile=0.5,
-                affect="EDGES",
-                clamp_overlap=True,
+            bmesh.ops.bevel(
+                bm, geom=edges, offset=IRON_BEVEL, segments=1, profile=0.5,
+                affect="EDGES", clamp_overlap=True, material=METAL_IDX,
             )
-            for f in ret.get("faces") or []:
-                f.material_index = WOOD_IDX
+        finish_caps(bm)
 
         xs = [v.co.x for v in bm.verts]
         ys = [v.co.y for v in bm.verts]
@@ -502,25 +688,75 @@ def build_cart_mesh(name, bevel_offset, bevel_segments):
             v.co.x -= cx
             v.co.y -= cy
             v.co.z -= zmin
-            if v.co.z < 0.0:
-                v.co.z = 0.0
 
         pack_uvs(bm)
         bmesh.ops.recalc_face_normals(bm, faces=list(bm.faces))
+        # Smooth across the felloe's, nave's and axle's facets; hard at every
+        # chamfer and material boundary, so a board stays a board.
         for face in bm.faces:
-            face.smooth = False
+            face.smooth = True
+        for edge in bm.edges:
+            edge.smooth = True
+            if len(edge.link_faces) == 2:
+                f0, f1 = edge.link_faces
+                if (f0.material_index != f1.material_index
+                        or edge.calc_face_angle(0.0) > math.radians(35.0)):
+                    edge.smooth = False
         me = bpy.data.meshes.new(name)
         bm.to_mesh(me)
         me.update()
-        for poly in me.polygons:
-            poly.use_smooth = False
     finally:
         bm.free()
+    paint_planks(me)
     out = bpy.data.objects.new(name, me)
     bpy.context.collection.objects.link(out)
     return out
 
 
+def _long_axis(pts):
+    """Principal axis of a point set, by power iteration on its covariance."""
+    c = sum(pts, Vector()) / len(pts)
+    cov = [[0.0] * 3 for _ in range(3)]
+    for p in pts:
+        d = p - c
+        for i in range(3):
+            for j in range(3):
+                cov[i][j] += d[i] * d[j]
+    v = Vector((1.0, 0.3, 0.1))
+    for _ in range(30):
+        w = Vector([sum(cov[i][j] * v[j] for j in range(3)) for i in range(3)])
+        if w.length < 1e-12:
+            break
+        v = w.normalized()
+    return v
+
+
+def paint_planks(me):
+    """Per-shell ``PlankTone`` and ``GrainDir`` face attributes for the wood shader.
+
+    Every plank, board, rail, leg, spoke and felloe is its own shell, so
+    each gets one seeded tone and grain along its own long axis.
+    """
+    tone = [0.5] * len(me.polygons)
+    grain = [(0.0, 0.0, 1.0)] * len(me.polygons)
+    owner = {}
+    rng = random.Random(TONE_SEED)
+    for g in shell_groups(me):
+        pts = [me.vertices[i].co.copy() for i in g]
+        d = _long_axis(pts) if len(pts) > 2 else Vector((0.0, 0.0, 1.0))
+        t = 0.5 + rng.uniform(-PLANK_TONE_JITTER, PLANK_TONE_JITTER)
+        for i in g:
+            owner[i] = (t, tuple(d))
+    for poly in me.polygons:
+        t, d = owner[poly.vertices[0]]
+        tone[poly.index] = t
+        grain[poly.index] = d
+    a = me.attributes.new("PlankTone", "FLOAT", "FACE")
+    a.data.foreach_set("value", tone)
+    b = me.attributes.new("GrainDir", "FLOAT_VECTOR", "FACE")
+    b.data.foreach_set("vector", [c for v in grain for c in v])
+
+
 def principled(name, color, metallic, roughness, noise_scale=0.0, wear=None):
     mat = bpy.data.materials.new(name)
     mat.use_nodes = True
@@ -551,6 +787,90 @@ def principled(name, color, metallic, roughness, noise_scale=0.0, wear=None):
     return mat
 
 
+def _sock(sockets, identifier):
+    """A Mix-node socket by identifier; its A/B/Result names repeat per type."""
+    return next(sk for sk in sockets if sk.identifier == identifier)
+
+
+def wood_material(name):
+    """Grain along each board and rail (``GrainDir``), tone per piece (``PlankTone``).
+
+    Copied from showcase/wheelbarrow (do not import across pieces).
+    """
+    mat = bpy.data.materials.new(name)
+    mat.use_nodes = True
+    nt = mat.node_tree
+    bsdf = nt.nodes["Principled BSDF"]
+    coord = nt.nodes.new("ShaderNodeTexCoord")
+    gdir = nt.nodes.new("ShaderNodeAttribute")
+    gdir.attribute_name = "GrainDir"
+    tone = nt.nodes.new("ShaderNodeAttribute")
+    tone.attribute_name = "PlankTone"
+    dot = nt.nodes.new("ShaderNodeVectorMath")
+    dot.operation = "DOT_PRODUCT"
+    nt.links.new(coord.outputs["Object"], dot.inputs[0])
+    nt.links.new(gdir.outputs["Vector"], dot.inputs[1])
+    squash = nt.nodes.new("ShaderNodeMath")
+    squash.operation = "MULTIPLY"
+    squash.inputs[1].default_value = 0.94
+    nt.links.new(dot.outputs["Value"], squash.inputs[0])
+    along = nt.nodes.new("ShaderNodeVectorMath")
+    along.operation = "SCALE"
+    nt.links.new(gdir.outputs["Vector"], along.inputs[0])
+    nt.links.new(squash.outputs["Value"], along.inputs["Scale"])
+    grain_co = nt.nodes.new("ShaderNodeVectorMath")
+    grain_co.operation = "SUBTRACT"
+    nt.links.new(coord.outputs["Object"], grain_co.inputs[0])
+    nt.links.new(along.outputs["Vector"], grain_co.inputs[1])
+    shift = nt.nodes.new("ShaderNodeVectorMath")
+    shift.operation = "ADD"
+    nt.links.new(grain_co.outputs["Vector"], shift.inputs[0])
+    nt.links.new(tone.outputs["Fac"], shift.inputs[1])
+    noise = nt.nodes.new("ShaderNodeTexNoise")
+    noise.inputs["Scale"].default_value = WOOD_GRAIN_SCALE
+    noise.inputs["Detail"].default_value = 6.0
+    noise.inputs["Roughness"].default_value = 0.62
+    nt.links.new(shift.outputs["Vector"], noise.inputs["Vector"])
+    ramp = nt.nodes.new("ShaderNodeValToRGB")
+    ramp.color_ramp.elements[0].position = 0.30
+    ramp.color_ramp.elements[0].color = (0.13, 0.058, 0.020, 1.0)
+    ramp.color_ramp.elements[1].position = 0.72
+    ramp.color_ramp.elements[1].color = (0.40, 0.20, 0.075, 1.0)
+    nt.links.new(noise.outputs["Fac"], ramp.inputs["Fac"])
+    gain = nt.nodes.new("ShaderNodeMath")
+    gain.operation = "MULTIPLY_ADD"
+    gain.inputs[1].default_value = 1.1
+    gain.inputs[2].default_value = 0.45
+    nt.links.new(tone.outputs["Fac"], gain.inputs[0])
+    mix = nt.nodes.new("ShaderNodeMix")
+    mix.data_type = "RGBA"
+    mix.blend_type = "MULTIPLY"
+    _sock(mix.inputs, "Factor_Float").default_value = 1.0
+    nt.links.new(ramp.outputs["Color"], _sock(mix.inputs, "A_Color"))
+    nt.links.new(gain.outputs["Value"], _sock(mix.inputs, "B_Color"))
+    nt.links.new(_sock(mix.outputs, "Result_Color"), bsdf.inputs["Base Color"])
+    rough = nt.nodes.new("ShaderNodeMapRange")
+    rough.inputs["To Min"].default_value = 0.72
+    rough.inputs["To Max"].default_value = 0.52
+    nt.links.new(noise.outputs["Fac"], rough.inputs["Value"])
+    nt.links.new(rough.outputs["Result"], bsdf.inputs["Roughness"])
+    return mat
+
+
+def cart_materials():
+    """(wood, iron): shared by the check, the render and inspection.
+
+    Forged iron, dark and rusted. The first build's metallic 1.0 at 0.50
+    roughness rendered the tyres as bright polished steel beside the wood.
+    """
+    wood = wood_material("CartWood")
+    metal = principled(
+        "CartIron", (0.17, 0.165, 0.155, 1.0), 0.80, 0.46,
+        noise_scale=18.0, wear=(0.20, 0.085, 0.032, 1.0),
+    )
+    return wood, metal
+
+
 def assign_slots(obj, wood, metal):
     mats = obj.data.materials
     wanted = (wood, metal)
@@ -570,6 +890,11 @@ def world_bbox(obj):
 
 
 def uv_stats(mesh):
+    """UV bounds and the summed pairwise AABB overlap area.
+
+    A sweep over boxes sorted by min u: the same pairs and the same sum as
+    the all-pairs loop, without its quadratic cost on a 4k-face piece.
+    """
     uv = mesh.uv_layers.active
     if uv is None:
         return 0.0, 0.0, 1.0, 1.0, 0, 1.0
@@ -581,16 +906,17 @@ def uv_stats(mesh):
         pu = [data[i].uv[0] for i in poly.loop_indices]
         pv = [data[i].uv[1] for i in poly.loop_indices]
         aabbs.append((min(pu), min(pv), max(pu), max(pv)))
+    aabbs.sort()
     overlap = 0.0
     for i in range(len(aabbs)):
         a = aabbs[i]
         for j in range(i + 1, len(aabbs)):
             b = aabbs[j]
-            x0 = max(a[0], b[0])
+            if b[0] >= a[2]:
+                break
             y0 = max(a[1], b[1])
-            x1 = min(a[2], b[2])
             y1 = min(a[3], b[3])
-            overlap += max(0.0, x1 - x0) * max(0.0, y1 - y0)
+            overlap += (min(a[2], b[2]) - b[0]) * max(0.0, y1 - y0)
     return min(us), min(vs), max(us), max(vs), overlap, len(aabbs)
 
 
@@ -654,7 +980,7 @@ def find(a):
     groups = {}
     for i in range(len(me.vertices)):
         groups.setdefault(find(i), []).append(i)
-    return sorted(groups.values(), key=lambda g: -len(g))
+    return sorted(groups.values(), key=lambda g: (-len(g), min(g)))
 
 
 def shell_box(me, idxs):
@@ -666,6 +992,14 @@ def shell_box(me, idxs):
     }
 
 
+def shell_mat(me, idxs):
+    member = set(idxs)
+    for p in me.polygons:
+        if p.vertices[0] in member:
+            return p.material_index
+    return None
+
+
 def coplanar_zfight_pairs(me, groups):
     """Coplanar face pairs from *different shells* — the z-fighting budget.
 
@@ -674,7 +1008,9 @@ def coplanar_zfight_pairs(me, groups):
     counting those makes the budget unsatisfiable rather than meaningful.
     Z-fighting is two separate bodies landing on one plane, which is
     exactly a cross-shell pair. Combinatorics and constants copied from
-    showcase/hay-bale (do not import across pieces).
+    showcase/hay-bale (do not import across pieces); candidate pairs come
+    from a KD-tree range query at COPLANAR_CENTRE_MAX, the same pairs the
+    all-pairs loop visits.
     """
     owner = {}
     for si, comp in enumerate(groups):
@@ -682,15 +1018,18 @@ def coplanar_zfight_pairs(me, groups):
             owner[vi] = si
     faces = [(p.normal.copy(), p.center.copy(), owner.get(p.vertices[0], -1))
              for p in me.polygons]
+    kd = KDTree(len(faces))
+    for i, (_n, c, _s) in enumerate(faces):
+        kd.insert(c, i)
+    kd.balance()
     hits = 0
-    for i in range(len(faces)):
-        ni, ci, si = faces[i]
-        for j in range(i + 1, len(faces)):
+    for i, (ni, ci, si) in enumerate(faces):
+        for _co, j, _d in kd.find_range(ci, COPLANAR_CENTRE_MAX):
+            if j <= i:
+                continue
             nj, cj, sj = faces[j]
             if si == sj:
                 continue
-            if (ci - cj).length > COPLANAR_CENTRE_MAX:
-                continue
             if abs(abs(ni.dot(nj)) - 1.0) > COPLANAR_NORMAL_EPS:
                 continue
             if abs(ni.dot(cj - ci)) > COPLANAR_PLANE_EPS:
@@ -703,7 +1042,7 @@ def wheel_shells(me, groups):
     """(rim, tyre) shell index pairs for each wheel, keyed by track side.
 
     Identified from the generated mesh by geometry — a shell centred on the
-    axle line whose YZ extent is a full disc — never from a construction
+    axle line whose XZ extent is a full disc — never from a construction
     constant. The tyre is the metal-indexed member of the pair.
     """
     metal = set()
@@ -785,11 +1124,12 @@ def break_tyre_seat(me, seat):
 
 
 def move_one_wheel(me, delta):
-    """Falsifier surgery: translate the +Y wheel only (rim, tyre, spokes).
+    """Falsifier surgery: translate the +Y wheel only, as one body.
 
-    Everything whose vertices lie on the +Y side of the axle centreline and
-    within the wheel's radius, so the assembly moves as one body and the
-    opposite wheel still grounds the AABB.
+    Moves every shell lying wholly inside that wheel's envelope — felloe,
+    tyre, nave, bands, washer, spokes — so the assembly stays intact and
+    the opposite wheel still grounds the AABB. The axle runs across both
+    wheels, so it is never wholly inside one and stays put.
     """
     groups = shell_groups(me)
     parts = wheel_shells(me, groups).get(1)
@@ -797,19 +1137,165 @@ def move_one_wheel(me, delta):
         return
     b = shell_box(me, groups[parts["tyre"]])
     cx, cz = _wheel_centre(me, groups, parts["rim"])
-    y_lo, y_hi = b["ymin"] - 0.02, b["ymax"] + 0.02
-    r_max = 0.5 * (b["xmax"] - b["xmin"]) + 1e-4
-    for v in me.vertices:
-        if not (y_lo <= v.co.y <= y_hi):
+    wy = 0.5 * (b["ymin"] + b["ymax"])
+    r_max = 0.5 * (b["xmax"] - b["xmin"]) + 1e-3
+    for g in groups:
+        inside = all(
+            math.hypot(me.vertices[i].co.x - cx, me.vertices[i].co.z - cz) <= r_max
+            and abs(me.vertices[i].co.y - wy) <= NAVE_L / 2.0 + 0.02
+            for i in g
+        )
+        if not inside:
             continue
-        if math.hypot(v.co.x - cx, v.co.z - cz) > r_max:
+        for i in g:
+            co = me.vertices[i].co
+            co.x += delta[0]
+            co.y += delta[1]
+            co.z += delta[2]
+    me.update()
+
+
+def lift_bed(me, dz):
+    """Falsifier surgery: raise the box — planks, walls, straps — off its rails.
+
+    The box is every shell whose floor sits at or above the rails' top less
+    the floor's bite, read off the mesh. Lifted by more than that bite, the
+    planks clear the rails and the box is joined to nothing below it.
+    """
+    groups = shell_groups(me)
+    rails = [g for g in groups
+             if shell_mat(me, g) == WOOD_IDX
+             and (shell_box(me, g)["xmax"] - shell_box(me, g)["xmin"]) > BED_L + 0.3]
+    if not rails:
+        return
+    rail_top = max(shell_box(me, g)["zmax"] for g in rails)
+    floor = rail_top - FLOOR_BITE - 1e-4
+    for g in groups:
+        if shell_box(me, g)["zmin"] < floor:
             continue
-        v.co.x += delta[0]
-        v.co.y += delta[1]
-        v.co.z += delta[2]
+        for i in g:
+            me.vertices[i].co.z += dz
     me.update()
 
 
+def support_audit(me, groups, wheels):
+    """Floor contact per named support: each tyre and each prop leg.
+
+    Legs are the wood shells that stand tall and thin; counted, so a leg a
+    classifier drops cannot pass vacuously.
+    """
+    out = {}
+    for side, parts in sorted(wheels.items()):
+        tb = shell_box(me, groups[parts["tyre"]])
+        out["tyre+Y" if side > 0 else "tyre-Y"] = tb["zmin"]
+    legs = []
+    for g in groups:
+        if shell_mat(me, g) != WOOD_IDX:
+            continue
+        b = shell_box(me, g)
+        if (b["zmax"] - b["zmin"]) > 0.3 and (b["xmax"] - b["xmin"]) < 0.06 \
+                and (b["ymax"] - b["ymin"]) < 0.06:
+            legs.append(b)
+    legs.sort(key=lambda b: b["ymin"])
+    for i, b in enumerate(legs):
+        out[f"leg{i}"] = b["zmin"]
+    return out, len(legs)
+
+
+def wall_board_audit(me, groups):
+    """Side-wall boards per side and the seam between each stacked pair.
+
+    Boards are the wood shells that run the bed's length, are one board
+    thick, and stand above the rails — read off the mesh.
+    """
+    rails_top = -1.0
+    for g in groups:
+        b = shell_box(me, g)
+        if shell_mat(me, g) == WOOD_IDX and (b["xmax"] - b["xmin"]) > BED_L + 0.3:
+            rails_top = max(rails_top, b["zmax"])
+    sides = {-1: [], 1: []}
+    for g in groups:
+        if shell_mat(me, g) != WOOD_IDX:
+            continue
+        b = shell_box(me, g)
+        if (b["xmax"] - b["xmin"]) < 0.8 * BED_L:
+            continue
+        if (b["ymax"] - b["ymin"]) > 2.0 * WALL_T or b["zmin"] < rails_top:
+            continue
+        sides[1 if b["ymin"] > 0 else -1].append(b)
+    seams = []
+    for boards in sides.values():
+        boards.sort(key=lambda b: b["zmin"])
+        for lo, hi in zip(boards, boards[1:]):
+            seams.append(hi["zmin"] - lo["zmax"])
+    return len(sides[-1]), len(sides[1]), seams
+
+
+def contact_components(me, groups):
+    """Components of the shells' BVH-overlap graph.
+
+    Every joint in the piece is a bite, so joined members' surfaces cross.
+    One component means every member is attached to the assembly; a second
+    is a part — or a whole sub-assembly — hanging in the air.
+    """
+    verts = [v.co.copy() for v in me.vertices]
+    owner = {}
+    for si, g in enumerate(groups):
+        for vi in g:
+            owner[vi] = si
+    polys = [[] for _ in groups]
+    for p in me.polygons:
+        polys[owner[p.vertices[0]]].append(tuple(p.vertices))
+    trees = [BVHTree.FromPolygons(verts, ps) if ps else None for ps in polys]
+    boxes = [shell_box(me, g) for g in groups]
+    parent = list(range(len(groups)))
+
+    def find(a):
+        while parent[a] != a:
+            parent[a] = parent[parent[a]]
+            a = parent[a]
+        return a
+
+    pad = 1e-4
+    for i in range(len(groups)):
+        for j in range(i + 1, len(groups)):
+            a, b = boxes[i], boxes[j]
+            if (a["xmin"] > b["xmax"] + pad or b["xmin"] > a["xmax"] + pad
+                    or a["ymin"] > b["ymax"] + pad or b["ymin"] > a["ymax"] + pad
+                    or a["zmin"] > b["zmax"] + pad or b["zmin"] > a["zmax"] + pad):
+                continue
+            if trees[i] is None or trees[j] is None:
+                continue
+            if trees[i].overlap(trees[j]):
+                ra, rb = find(i), find(j)
+                if ra != rb:
+                    parent[rb] = ra
+    return len({find(i) for i in range(len(groups))})
+
+
+def right_angle_edges(me):
+    """Manifold edges whose two faces meet at 90 degrees, iron and timber.
+
+    Every box and ring in the piece is chamfered, and a chamfer turns a
+    90-degree edge into two shallower ones. An edge still at 90 is one a
+    bevel pass skipped: the razor edge that renders as a hard black line.
+    Copied from showcase/crate-stack (do not import across pieces).
+    """
+    counts = {WOOD_IDX: 0, METAL_IDX: 0}
+    bm = bmesh.new()
+    try:
+        bm.from_mesh(me)
+        for e in bm.edges:
+            if len(e.link_faces) != 2:
+                continue
+            if abs(e.calc_face_angle(0.0) - math.pi / 2.0) <= RIGHT_ANGLE_TOL:
+                idx = e.link_faces[0].material_index
+                counts[idx] = counts.get(idx, 0) + 1
+    finally:
+        bm.free()
+    return counts
+
+
 def min_mat_distance(me, ia, ib):
     """Closest surface distance between two material islands via BVH.
 
@@ -879,6 +1365,27 @@ def convex_hull_collider(obj, name):
     return collider
 
 
+def texel_audit(mesh, img):
+    """Smallest UV cell, in baked texels along its longer side.
+
+    Every face packs into its own UV cell, so a small image spreads a few
+    texels over each face and the render's bilinear lookup reads the next
+    cell's normals across the border. Copied from showcase/tavern-stool
+    (do not import across pieces).
+    """
+    uv = mesh.uv_layers.active
+    if uv is None or img is None:
+        return 0.0
+    res = min(img.size[0], img.size[1])
+    data = uv.data
+    worst = 1e9
+    for poly in mesh.polygons:
+        us = [data[i].uv[0] for i in poly.loop_indices]
+        vs = [data[i].uv[1] for i in poly.loop_indices]
+        worst = min(worst, max(max(us) - min(us), max(vs) - min(vs)) * res)
+    return worst
+
+
 def setup_bake_image(obj, target_mat, size=BAKE_RES):
     if not obj.data.uv_layers:
         return None, None
@@ -931,24 +1438,19 @@ def export_unity(path, objects):
     )
 
 
+def _no():
+    return None, None, None, None, None
+
+
 def check(skip_decimate, lift_z=False, flush_tyre=False, sink_tyre=False,
-          float_wheel=False, skew_wheel=False):
+          float_wheel=False, skew_wheel=False, short_props=False,
+          wide_seams=False, lift_bed_flag=False, sharp_bar=False,
+          low_bake=False):
     bpy.ops.wm.read_factory_settings(use_empty=True)
-    low = build_cart_mesh("CartLow", bevel_offset=0.005, bevel_segments=2)
-    high = build_cart_mesh("CartHigh", bevel_offset=0.005, bevel_segments=4)
-    wood = principled(
-        "CartWood", (0.42, 0.22, 0.08, 1.0), 0.0, 0.58,
-        noise_scale=7.0, wear=(0.26, 0.12, 0.04, 1.0),
-    )
-    # Wrought iron, not black plastic. At (0.13, 0.32) the tyre rendered as
-    # a flat black band with no sheen — darker and glossier than every
-    # sibling piece's iron (hitching-post 0.16/0.48, wooden-ladder
-    # 0.18/0.48). Raised to sit inside that calibration range, and the wear
-    # colour lifted off near-black so the noise actually varies the surface.
-    metal = principled(
-        "CartIron", (0.20, 0.195, 0.185, 1.0), 1.0, 0.50,
-        noise_scale=5.0, wear=(0.11, 0.105, 0.10, 1.0),
-    )
+    flags = dict(sharp_bar=sharp_bar, wide_seams=wide_seams, short_props=short_props)
+    low = build_cart_mesh("CartLow", 0.005, 1, **flags)
+    high = build_cart_mesh("CartHigh", 0.005, 3, **flags)
+    wood, metal = cart_materials()
     assign_slots(low, wood, metal)
     assign_slots(high, wood, metal)
     if lift_z:
@@ -963,9 +1465,11 @@ def check(skip_decimate, lift_z=False, flush_tyre=False, sink_tyre=False,
         move_one_wheel(low.data, (0.0, 0.0, FLOAT_WHEEL_Z))
     if skew_wheel:
         move_one_wheel(low.data, (0.0, SKEW_WHEEL_Y, 0.0))
+    if lift_bed_flag:
+        lift_bed(low.data, LIFT_BED)
 
     if low.data is None or len(low.data.polygons) < 6:
-        return fail("cart mesh did not build", 3), None, None, None, None, None
+        return (fail("cart mesh did not build", 3),) + _no()
 
     base_tris = triangle_count(low.data)
     mats = [s for s in low.data.materials if s is not None]
@@ -981,10 +1485,12 @@ def check(skip_decimate, lift_z=False, flush_tyre=False, sink_tyre=False,
     size_y = bb[4] - bb[1]
     size_z = bb[5] - bb[2]
 
-    img, tex = setup_bake_image(low, wood)
+    img, tex = setup_bake_image(low, wood, LOW_BAKE_RES if low_bake else BAKE_RES)
     if img is None:
-        return fail("cart has no UV layer", 3), None, None, None, None, None
+        return (fail("cart has no UV layer", 3),) + _no()
     bake_result = bake_normal(high, low)
+    texel = texel_audit(low.data, img)
+    print(f"measured bake_res={img.size[0]} texel_min={texel:.2f}")
 
     lod1 = make_lod(low, "CartLOD1", LOD1_TARGET, skip_decimate)
     lod2 = make_lod(low, "CartLOD2", LOD2_TARGET, skip_decimate)
@@ -994,7 +1500,7 @@ def check(skip_decimate, lift_z=False, flush_tyre=False, sink_tyre=False,
     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_cart_mesh("CartColSrc", bevel_offset=0.0, bevel_segments=1)
+    collider_src = build_cart_mesh("CartColSrc", 0.0, 1)
     collider = convex_hull_collider(collider_src, "CartCollider")
     bpy.data.objects.remove(collider_src, do_unlink=True)
     col_tris = triangle_count(collider.data)
@@ -1046,16 +1552,14 @@ def check(skip_decimate, lift_z=False, flush_tyre=False, sink_tyre=False,
     groups = shell_groups(low.data)
     zfight = coplanar_zfight_pairs(low.data, groups)
     wheels = wheel_shells(low.data, groups)
-    support_zmins = {}
+    supports, n_legs = support_audit(low.data, groups, wheels)
     seats = []
     for side, parts in sorted(wheels.items()):
-        tb = shell_box(low.data, groups[parts["tyre"]])
-        support_zmins["+Y" if side > 0 else "-Y"] = round(tb["zmin"], 6)
         depths, _ = tyre_seat_depths(
             low.data, groups, parts["rim"], parts["tyre"], WHEEL_SEGMENTS
         )
         seats.extend(depths)
-    support_worst = max((abs(z) for z in support_zmins.values()), default=1e9)
+    support_worst = max((abs(z) for z in supports.values()), default=1e9)
     seat_min = min(seats) if seats else -1.0
     seat_max = max(seats) if seats else 1e9
     seat_n = len(seats)
@@ -1078,81 +1582,74 @@ def check(skip_decimate, lift_z=False, flush_tyre=False, sink_tyre=False,
             abs(a[0] - b2[0]), abs(a[1] + b2[1]), abs(a[2] - b2[2]),
             abs(a[3] - b2[3]), abs(a[4] - b2[4]),
         )
+    n_left, n_right, seams = wall_board_audit(low.data, groups)
+    seam_lo = min(seams) if seams else -1.0
+    seam_hi = max(seams) if seams else 1e9
+    components = contact_components(low.data, groups)
+    right_angles = right_angle_edges(low.data)
+    n_right_angles = sum(right_angles.values())
     print(
         f"measured zfight_pairs={zfight} shells={len(groups)} "
-        f"support_zmin={support_zmins} "
+        f"supports={ {k: round(v, 6) for k, v in supports.items()} } legs={n_legs} "
         f"tyre_seat=[{seat_min:.5f},{seat_max:.5f}] over {seat_n} stations "
         f"wheel_mirror={wheel_mirror*1000:.5f}mm"
     )
+    print(
+        f"measured wall_boards=({n_left},{n_right}) "
+        f"seams=[{seam_lo:.5f},{seam_hi:.5f}] components={components} "
+        f"right_angle_edges={right_angles}"
+    )
 
     if len(wheels) != 2 or any(len(p) != 2 for p in wheels.values()):
-        return fail(
-            f"expected 2 wheels of (rim, tyre) shells, found {wheels}",
-            3,
-        ), None, None, None, None, None
+        return (fail(f"expected 2 wheels of (rim, tyre) shells, found {wheels}", 3),) + _no()
     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}]",
-            4,
-        ), None, None, None, None, None
+        return (fail(
+            f"base tris {base_tris} not in [{BASE_TRIS_MIN}, {BASE_TRIS_MAX}]", 4,
+        ),) + _no()
     if nmat != MATERIAL_COUNT or distinct_mats != MATERIAL_COUNT:
-        return fail(
-            f"material slots {nmat} distinct {distinct_mats} != {MATERIAL_COUNT}",
-            5,
-        ), None, None, None, None, None
+        return (fail(
+            f"material slots {nmat} distinct {distinct_mats} != {MATERIAL_COUNT}", 5,
+        ),) + _no()
     if idx_counts.get(METAL_IDX, 0) < METAL_FACES_MIN:
-        return fail(
-            f"metal faces {idx_counts.get(METAL_IDX, 0)} < {METAL_FACES_MIN}",
-            5,
-        ), None, None, None, None, None
+        return (fail(
+            f"metal faces {idx_counts.get(METAL_IDX, 0)} < {METAL_FACES_MIN}", 5,
+        ),) + _no()
     if idx_counts.get(WOOD_IDX, 0) < WOOD_FACES_MIN:
-        return fail(
-            f"wood faces {idx_counts.get(WOOD_IDX, 0)} < {WOOD_FACES_MIN}",
-            5,
-        ), None, None, None, None, None
+        return (fail(
+            f"wood faces {idx_counts.get(WOOD_IDX, 0)} < {WOOD_FACES_MIN}", 5,
+        ),) + _no()
     if u0 < -UV_EPS or v0 < -UV_EPS or u1 > 1.0 + UV_EPS or v1 > 1.0 + UV_EPS:
-        return fail(
-            f"UVs outside 0..1: ({u0:.4f},{v0:.4f})-({u1:.4f},{v1:.4f})",
-            6,
-        ), None, None, None, None, None
+        return (fail(
+            f"UVs outside 0..1: ({u0:.4f},{v0:.4f})-({u1:.4f},{v1:.4f})", 6,
+        ),) + _no()
     if overlap > UV_OVERLAP_MAX:
-        return fail(
-            f"UV AABB overlap {overlap:.6f} > {UV_OVERLAP_MAX}",
-            7,
-        ), None, None, None, None, None
+        return (fail(f"UV AABB overlap {overlap:.6f} > {UV_OVERLAP_MAX}", 7),) + _no()
     if (
         abs(size_x - OUTER_SIZE[0]) > BBOX_TOL
         or abs(size_y - OUTER_SIZE[1]) > BBOX_TOL
         or abs(size_z - OUTER_SIZE[2]) > BBOX_TOL
     ):
-        return fail(
-            f"bbox ({size_x:.4f},{size_y:.4f},{size_z:.4f}) "
-            f"off outer {OUTER_SIZE}",
-            8,
-        ), None, None, None, None, None
+        return (fail(
+            f"bbox ({size_x:.4f},{size_y:.4f},{size_z:.4f}) off outer {OUTER_SIZE}", 8,
+        ),) + _no()
     if not (LOD1_RATIO_MIN <= r1 <= LOD1_RATIO_MAX):
-        return fail(
+        return (fail(
             f"LOD1 ratio {r1:.4f} not in [{LOD1_RATIO_MIN}, {LOD1_RATIO_MAX}] "
             "(--skip-decimate is the designed fail)",
             9,
-        ), None, None, None, None, None
+        ),) + _no()
     if not (LOD2_RATIO_MIN <= r2 <= LOD2_RATIO_MAX):
-        return fail(
-            f"LOD2 ratio {r2:.4f} not in [{LOD2_RATIO_MIN}, {LOD2_RATIO_MAX}]",
-            9,
-        ), None, None, None, None, None
+        return (fail(
+            f"LOD2 ratio {r2:.4f} not in [{LOD2_RATIO_MIN}, {LOD2_RATIO_MAX}]", 9,
+        ),) + _no()
     if col_tris > COLLIDER_TRIS_MAX:
-        return fail(
-            f"collider tris {col_tris} > {COLLIDER_TRIS_MAX}",
-            11,
-        ), None, None, None, None, None
+        return (fail(f"collider tris {col_tris} > {COLLIDER_TRIS_MAX}", 11),) + _no()
     if bake_result != {"FINISHED"} or not img.has_data:
-        return fail(
-            f"bake failed result={bake_result} has_data={img.has_data}",
-            12,
-        ), None, None, None, None, None
+        return (fail(
+            f"bake failed result={bake_result} has_data={img.has_data}", 12,
+        ),) + _no()
     if export_size <= 0:
-        return fail("export file missing or empty", 13), None, None, None, None, None
+        return (fail("export file missing or empty", 13),) + _no()
     if (
         hyg["loose_v"]
         or hyg["loose_e"]
@@ -1161,55 +1658,85 @@ def check(skip_decimate, lift_z=False, flush_tyre=False, sink_tyre=False,
         or hyg["doubles"]
         or hyg["ngons"]
     ):
-        return fail(
+        return (fail(
             f"hygiene loose_v={hyg['loose_v']} loose_e={hyg['loose_e']} "
             f"nonman={hyg['nonman']} zero_area={hyg['zero_area']} "
             f"doubles={hyg['doubles']} ngons={hyg['ngons']}",
             15,
-        ), None, None, None, None, None
+        ),) + _no()
     if zfight > ZFIGHT_PAIRS_MAX:
-        return fail(
+        return (fail(
             f"coplanar cross-shell face pairs {zfight} > {ZFIGHT_PAIRS_MAX} "
             "(--flush-tyre is the designed fail: a tyre whose inner radius "
             "equals the felloe's outer radius puts both on one plane)",
             15,
-        ), None, None, None, None, None
+        ),) + _no()
     if abs(bb[2]) > ZMIN_EPS:
-        return fail(
+        return (fail(
             f"zmin {bb[2]:.6f} not within {ZMIN_EPS} of 0 "
             "(--lift-z is the designed fail)",
             16,
-        ), None, None, None, None, None
-    if support_worst > SUPPORT_ZMIN_EPS:
-        return fail(
-            f"named support zmin {support_worst:.6f} > {SUPPORT_ZMIN_EPS} "
-            f"per-tyre zmin={support_zmins} "
-            "(--float-wheel is the designed fail: one tyre off the floor "
-            "while the other still grounds the AABB)",
+        ),) + _no()
+    if n_legs != N_LEGS or support_worst > SUPPORT_ZMIN_EPS:
+        return (fail(
+            f"named supports {supports} legs={n_legs}: worst zmin "
+            f"{support_worst:.6f} > {SUPPORT_ZMIN_EPS} "
+            "(--float-wheel and --short-props are the designed fails: one "
+            "support off the floor while the rest still ground the AABB)",
             16,
-        ), None, None, None, None, None
+        ),) + _no()
     if gap_mw > GAP_MAX:
-        return fail(
+        return (fail(
             f"metal-wood gap {gap_mw:.5f} > {GAP_MAX} "
-            "(tyres, hubs, straps, and plates must touch the wood they mount to)",
+            "(tyres, bands, washers and straps must touch the wood they mount to)",
             17,
-        ), None, None, None, None, None
+        ),) + _no()
+    if (n_left, n_right) != (WALL_BOARDS, WALL_BOARDS) or not (
+        WALL_SEAM_MIN <= seam_lo and seam_hi <= WALL_SEAM_MAX
+    ):
+        return (fail(
+            f"side-wall boards ({n_left},{n_right}) != {WALL_BOARDS} per side or "
+            f"seams [{seam_lo:.5f},{seam_hi:.5f}] outside "
+            f"[{WALL_SEAM_MIN}, {WALL_SEAM_MAX}] "
+            "(--wide-seams is the designed fail)",
+            17,
+        ),) + _no()
     if seat_min < TYRE_SEAT_MIN or seat_max > TYRE_SEAT_MAX:
-        return fail(
+        return (fail(
             f"tyre seat depth band [{seat_min:.5f}, {seat_max:.5f}] outside "
             f"[{TYRE_SEAT_MIN}, {TYRE_SEAT_MAX}] over {seat_n} stations "
             "(--sink-tyre is the designed fail: the hoop swallowed by the "
             "felloe reads as one body, not a tyre)",
             18,
-        ), None, None, None, None, None
+        ),) + _no()
+    if components != CONTACT_COMPONENTS:
+        return (fail(
+            f"shell contact graph has {components} components, expected "
+            f"{CONTACT_COMPONENTS} (--lift-bed is the designed fail: the box "
+            "raised off its rails is joined to nothing below it)",
+            18,
+        ),) + _no()
     if wheel_mirror > WHEEL_MIRROR_EPS:
-        return fail(
+        return (fail(
             f"wheel mirror deviation {wheel_mirror*1000:.4f} mm > "
             f"{WHEEL_MIRROR_EPS*1000:.4f} mm "
             "(--skew-wheel is the designed fail: the two wheels are one part "
             "reflected in Y and must sit at matched X and Z)",
             19,
-        ), None, None, None, None, None
+        ),) + _no()
+    if n_right_angles > RIGHT_ANGLE_MAX:
+        return (fail(
+            f"right-angle edges {right_angles} > {RIGHT_ANGLE_MAX} "
+            "(--sharp-bar is the designed fail: the pull bar left unchamfered)",
+            20,
+        ),) + _no()
+    if texel < TEXEL_MIN:
+        return (fail(
+            f"bake texel density {texel:.2f} px per UV cell < {TEXEL_MIN} "
+            "(--low-bake is the designed fail: a 256 px bake smears each "
+            "face's normals into its neighbours')",
+            21,
+        ),) + _no()
     return 0, low, high, wood, tex, collider
 
 
@@ -1236,7 +1763,7 @@ def render_still(low, wood, tex, path, engine):
     floor_me = bpy.data.meshes.new("Floor")
     bm = bmesh.new()
     try:
-        bmesh.ops.create_grid(bm, x_segments=1, y_segments=1, size=14.0)
+        bmesh.ops.create_grid(bm, x_segments=1, y_segments=1, size=60.0)
         bm.to_mesh(floor_me)
     finally:
         bm.free()
@@ -1356,6 +1883,36 @@ def main():
         help="falsification: push one wheel out along the track so the "
              "wheel-mirror budget fails",
     )
+    p.add_argument(
+        "--short-props",
+        action="store_true",
+        help="falsification: stop both prop legs 3 mm above the floor while "
+             "the tyres still ground the AABB, so the named-support budget fails",
+    )
+    p.add_argument(
+        "--wide-seams",
+        action="store_true",
+        help="falsification: open the wall-board seams to 10 mm (same "
+             "triangles), so the board-seam budget fails",
+    )
+    p.add_argument(
+        "--lift-bed",
+        action="store_true",
+        help="falsification: raise the box off its rails, so the contact "
+             "graph splits and the one-assembly budget fails",
+    )
+    p.add_argument(
+        "--sharp-bar",
+        action="store_true",
+        help="falsification: leave the pull bar's rims unchamfered, so the "
+             "edge-treatment budget fails",
+    )
+    p.add_argument(
+        "--low-bake",
+        action="store_true",
+        help="falsification: bake the normal map at 256 px, so the "
+             "texel-density budget fails",
+    )
     args = p.parse_args(argv)
 
     code, low, _high, wood, tex, _col = check(
@@ -1365,6 +1922,11 @@ def main():
         sink_tyre=args.sink_tyre,
         float_wheel=args.float_wheel,
         skew_wheel=args.skew_wheel,
+        short_props=args.short_props,
+        wide_seams=args.wide_seams,
+        lift_bed_flag=args.lift_bed,
+        sharp_bar=args.sharp_bar,
+        low_bake=args.low_bake,
     )
     if code:
         return code
diff --git a/showcase/cart/preview.webp b/showcase/cart/preview.webp
index f2016f39..d6bcbbb6 100644
Binary files a/showcase/cart/preview.webp and b/showcase/cart/preview.webp differ
diff --git a/showcase/gallery.json b/showcase/gallery.json
index f8b43002..63695abd 100644
--- a/showcase/gallery.json
+++ b/showcase/gallery.json
@@ -140,9 +140,9 @@
     {
       "name": "cart",
       "dir": "showcase/cart",
-      "teaches": "A procedural two-wheel wooden cart through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.",
-      "alt": "A two-wheeled wooden cart with spoked wheels, an open box bed and long shafts resting on the floor.",
-      "witnessesFix": "Recomputed: 2856 tris, two materials with metal and wood face floors, UVs in 0..1 with zero AABB overlap, outer AABB 1.539×0.749×0.640 m, LOD ratios in band, convex collider 154 tris, hygiene zero (loose, non-manifold, doubles, n-gons), zero coplanar cross-shell face pairs, both tyres grounded, tyre seat depth in band over 48 angular stations, the two wheels mirrored within 5e-5 m, grounded zmin, non-empty glTF. --flush-tyre exits 15 on the z-fight budget; --sink-tyre exits 18 on the tyre seat band; --float-wheel exits 16 on the named-support budget; --skew-wheel exits 19 on the wheel mirror; --skip-decimate exits 9 on the LOD1 ratio budget; --lift-z exits 16 on the grounded budget.",
+      "teaches": "A procedural two-wheel handcart through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.",
+      "alt": "A wooden handcart with a planked box bed and iron corner straps on two spoked wheels, standing level on two prop legs with its shafts joined by a pull bar.",
+      "witnessesFix": "Recomputed: 5284 tris, two materials with metal and wood face floors, UVs in 0..1 with zero AABB overlap, outer AABB 1.580×0.842×0.640 m, LOD ratios in band, convex collider 192 tris, hygiene zero (loose, non-manifold, doubles, n-gons), zero coplanar cross-shell face pairs, both tyres and both prop legs grounded, two wall boards per side with 3 mm seams, tyre seat depth in band over 48 angular stations, every shell in one BVH-contact assembly, the two wheels mirrored within 5e-5 m, no unchamfered right-angle edge, 17.45 bake texels per UV cell, non-empty glTF. --flush-tyre exits 15 on the z-fight budget; --float-wheel and --short-props exit 16 on the named-support budget; --wide-seams exits 17 on the board seams; --sink-tyre exits 18 on the tyre seat band; --lift-bed exits 18 on the one-assembly budget; --skew-wheel exits 19 on the wheel mirror; --sharp-bar exits 20 on edge treatment; --low-bake exits 21 on texel density; --skip-decimate exits 9 on the LOD1 ratio budget; --lift-z exits 16 on the grounded budget.",
       "hero": "docs/gallery/assets/cart-hero.webp",
       "preview": "showcase/cart/preview.webp",
       "tags": [
@@ -221,8 +221,8 @@
       "name": "grindstone",
       "dir": "showcase/grindstone",
       "teaches": "A procedural grindstone on a timber trestle through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.",
-      "alt": "A round grey grindstone with a crank handle, mounted in a wooden A-frame trestle.",
-      "witnessesFix": "Recomputed: 928 tris, three materials with 216 wood / 160 stone / 180 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.710×0.419×0.610 m, zmin 0, hygiene 0, four shoes planted, trough seated in the sills, stone dip 26 mm, LOD ratios in band (5.2 COLLAPSE leaner on LOD2), convex collider 198 tris, non-empty glTF. --skip-decimate exits 9 on LOD1; --stray-vert exits 15 on hygiene; --lift-z / --short-legs exit 16 on grounded; --float-crank / --float-legs exit 17 on joint fit; --no-dip / --narrow-trough exit 18 on seat.",
+      "alt": "A sandstone grindstone wheel with an iron crank, turning in a chamfered timber A-frame over an open trough, its sills capped by iron shoes.",
+      "witnessesFix": "Recomputed: 1668 tris, three materials with 400 wood / 240 stone / 364 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.722×0.419×0.610 m, zmin 0, hygiene 0 including zero coplanar cross-shell pairs, four shoes planted, trough seated in the sills and biting both stretchers 4 mm, stone dip 24 mm, no unchamfered right-angle edge, 29.44 bake texels per UV cell, LOD ratios in band, convex collider 304 tris, non-empty glTF. --skip-decimate exits 9 on LOD1; --stray-vert / --flush-shoes exit 15 on hygiene; --lift-z / --short-legs exit 16 on grounded; --float-crank / --float-legs exit 17 on joint fit; --no-dip / --narrow-trough / --low-stretchers exit 18 on seat; --sharp-handle exits 20 on edge treatment; --low-bake exits 21 on texel density.",
       "hero": "docs/gallery/assets/grindstone-hero.webp",
       "preview": "showcase/grindstone/preview.webp",
       "tags": [
diff --git a/showcase/grindstone/README.md b/showcase/grindstone/README.md
index 80961f32..9db29c4f 100644
--- a/showcase/grindstone/README.md
+++ b/showcase/grindstone/README.md
@@ -1,14 +1,19 @@
 # Grindstone
 
-A showcase piece, not an example. Procedural grindstone (sandstone
-wheel, timber A-frame trestle, iron shoes/axle/hubs/crank, open water
-trough) then the shipped pipeline: unique-cell UVs, Cycles high-to-low
-normal bake, LOD chain, convex collider, Unity glTF export.
-
-The A-frame is a king post with diagonals tenoning into a fatter sill,
-not two sticks meeting at a point. The trough is one manifold basin
-seated into those sills. Iron shoes bury a short wood tenon so the
-angled leg end-cap cannot pierce Z=0.
+A showcase piece, not an example. A procedural grindstone: a sandstone
+wheel, a timber A-frame trestle, iron shoes, axle, hubs and crank, and an
+open trough. The piece then runs the shipped pipeline: unique-cell UVs, a
+Cycles high-to-low normal bake, an LOD chain, a convex collider, and a
+Unity glTF export.
+
+Each A-frame is a king post with two diagonals tenoned 12 mm into its
+faces and into a fatter sill. It is not two sticks meeting at a point. The
+sills stand in iron shoes, cups one 6 mm reveal proud of the sill on every
+side. The trough is one manifold basin seated into the sills and carried
+on two end stretchers, which it bites by 4 mm. Every timber and iron edge
+is chamfered. The stone is 48 smooth segments with hard chamfer rings, in
+a mottled sandstone material. Stated size is a 0.50 m × 0.095 m stone in a
+0.72 × 0.42 × 0.61 m frame.
 
 It asserts **budget conformance** of the generated result. It does not
 witness an API contract. "It rendered without error" is not a check.
@@ -26,14 +31,18 @@ materials, UVs, evaluated LOD, collider, or export file.
 
 | Axis | Declared | Measured (4.5.11 / 5.1.2 / 5.2.1) |
 | --- | --- | --- |
-| Base triangles | 700–1000 | 928 / 928 / 928 |
+| Base triangles | 1560–1780 | 1668 / 1668 / 1668 |
 | 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.1897 |
-| Materials | exactly 3 distinct; ≥80 wood, stone, metal faces | 3 slots; 216 / 160 / 180 |
+| LOD2 ratio | 0.10–0.35 of base | 0.2194 / 0.2194 / 0.2194 |
+| Materials | exactly 3 distinct; ≥ 280 wood, ≥ 190 stone, ≥ 260 metal faces | 3 slots; 400 / 240 / 364 |
 | UVs | in `0..1`, AABB overlap ≤ 1e-5 | in range, overlap 0 |
-| Outer AABB | (0.710, 0.419, 0.610) m ± 0.015 | (0.7100, 0.4185, 0.6100), zmin 0 |
-| Collider tris | ≤ 240 | 198 |
-| Export | written, size > 0 | 89316 / 89316 / 89312 bytes |
+| Outer AABB | (0.722, 0.419, 0.610) m ± 0.015 | (0.7220, 0.4185, 0.6100), zmin 0 |
+| Collider tris | ≤ 320 | 304 |
+| Bake texels | smallest UV cell ≥ 12 px at the baked resolution | 29.44 px at 1024 px |
+| Export | written, size > 0 | 152272 / 152272 / 152260 bytes |
+
+The collider ceiling moved from 240 to 320 with the stone. 48 segments
+put more of its rim on the hull (198 → 304 triangles).
 
 ### Hygiene
 
@@ -46,42 +55,59 @@ Recomputed from the generated mesh, not asserted about the script.
 | Doubles merged at 1e-5 | 0 | 0 |
 | Zero-area faces | 0 | 0 |
 | N-gons | 0 | 0 |
-| Coplanar disjoint face pairs | 0 | 0 |
+| Coplanar cross-shell face pairs | 0 | 0 |
 | Grounded: `zmin` | within 1e-4 of 0 | 0.0000 |
 | Named supports: 4 shoes | each `zmin` ≤ 1e-3 | 4, shoe_z 0.00000 |
 | Stone size | 0.500 m dia × 0.095 m thick ± 0.02 / ± 0.015 | 0.5000 × 0.0950 |
+| Edge treatment | manifold edges within 5° of 90° = 0 | 0 wood, 0 stone, 0 iron |
+
+The coplanar budget counts pairs from different shells within 0.05 m,
+using `hay-bale`'s constants. The first build matched only faces whose
+centres fell within 0.1 mm of each other, and no real overlap ever does.
+It reported 0 while the shoes shared three planes with every sill end,
+seen as a lit slit in each foot close-up.
 
 ### Joint fit and seat
 
 | Axis | Declared | Measured (all three) |
 | --- | --- | --- |
-| Crank-axle gap | ≤ 0.008 m | 0.00418 |
+| Crank-axle gap | ≤ 0.008 m | 0.00376 |
 | Shoe-wood BVH gap | ≤ 0.008 m (overlap is 0) | 0.00000 |
 | Trough-sill per-side gap | ≤ 0.008 m (overlap is 0) | 0.00000 |
-| Stone dip into trough | 0.015–0.045 m | 0.02570 |
+| Stone dip into trough | 0.015–0.045 m | 0.02416 |
 | Trough floor zmin | ≥ 0.040 m | 0.05800 |
+| Trough bearing | 2 end stretchers, each biting the trough floor 0.002–0.008 m | 2, [0.00400, 0.00400] |
 
-DECIMATE COLLAPSE triangle counts are **not** identical across series —
-5.2.1 is leaner on LOD2. The gate is a ratio band, not an exact count.
-Bake pixels are stochastic; the gate is `has_data` plus operator
-`FINISHED`, not byte-identity. Construction uses no RNG. Export byte
-counts differ by 4 B on 5.2.1 (glTF serializer), not a gated axis.
+DECIMATE COLLAPSE triangle counts can differ across series, so the gate is
+a ratio band, not an exact count. Bake pixels are stochastic. The gate is
+`has_data` plus operator `FINISHED` plus the texel floor, not
+byte-identity. Per-member wood tone comes from `random.Random(TONE_SEED)`,
+so it is identical run to run. Export byte counts differ by 12 B on 5.2.1
+(glTF serializer), which is not a gated axis.
 
-### Falsifiers
+## Falsifiers
 
-Each violates one named budget. All nine were run on 4.5.11, 5.1.2 and
-5.2.1 and returned the same code on each.
+Each violates one named budget. All thirteen 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 |
+| `--flush-shoes` | coplanar cross-shell pairs: shoes sized to the sill and flush with its end (0 → 4 pairs) | 15 |
 | `--lift-z` | bounding box `zmin` is 0 | 16 |
 | `--short-legs` | named shoe supports at Z=0 | 16 |
 | `--float-crank` | crank-axle gap | 17 |
 | `--float-legs` | shoe-wood join | 17 |
-| `--no-dip` | stone dip band | 18 |
 | `--narrow-trough` | trough-sill seat | 18 |
+| `--no-dip` | stone dip band | 18 |
+| `--low-stretchers` | trough bearing: stretchers back at sill height, 5.9 mm under the trough | 18 |
+| `--sharp-handle` | edge treatment: the crank handle's rims left square (20 right-angle edges) | 20 |
+| `--low-bake` | bake texel density: 256 px bake (7.36 px per cell) | 21 |
+
+`--flush-shoes` moves the shoe envelope 12 mm inside `BBOX_TOL` (15 mm),
+so the AABB gate cannot steal it. `--sharp-handle` leaves the triangle
+count inside its band, so only the edge budget sees it.
 
 ## Run
 
@@ -89,12 +115,16 @@ Each violates one named budget. All nine were run on 4.5.11, 5.1.2 and
 blender --background --python grindstone.py --
 blender --background --python grindstone.py -- --skip-decimate
 blender --background --python grindstone.py -- --stray-vert
+blender --background --python grindstone.py -- --flush-shoes
 blender --background --python grindstone.py -- --lift-z
 blender --background --python grindstone.py -- --short-legs
 blender --background --python grindstone.py -- --float-crank
 blender --background --python grindstone.py -- --float-legs
-blender --background --python grindstone.py -- --no-dip
 blender --background --python grindstone.py -- --narrow-trough
+blender --background --python grindstone.py -- --no-dip
+blender --background --python grindstone.py -- --low-stretchers
+blender --background --python grindstone.py -- --sharp-handle
+blender --background --python grindstone.py -- --low-bake
 blender --background --python grindstone.py -- --output grindstone.png
 ```
 
@@ -123,8 +153,10 @@ hygiene and joint-fit family.
 | 12 | Bake did not finish or image has no data |
 | 13 | Export file missing or empty |
 | 14 | `--output` produced no file |
-| 15 | Mesh hygiene: loose, non-manifold, zero-area, doubles, n-gons, z-fight |
+| 15 | Mesh hygiene: loose, non-manifold, zero-area, doubles, n-gons, coplanar cross-shell pairs |
 | 16 | Not grounded: bounding box `zmin` off 0, or a named shoe floats |
 | 17 | Joint fit: crank-axle gap, or shoe-wood join |
-| 18 | Seat: trough-sill gap, stone dip band, or trough sitting on the dirt |
+| 18 | Seat: trough-sill gap, stone dip band, trough on the dirt, or trough not bearing on its stretchers |
 | 19 | Stone diameter or thickness off the stated real-world size |
+| 20 | A right-angle edge survived the chamfer passes (`--sharp-handle` lands here) |
+| 21 | Bake texel density below the floor (`--low-bake` lands here) |
diff --git a/showcase/grindstone/grindstone.py b/showcase/grindstone/grindstone.py
index c6fe4717..536b2437 100644
--- a/showcase/grindstone/grindstone.py
+++ b/showcase/grindstone/grindstone.py
@@ -9,18 +9,25 @@
 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. ``--stray-vert`` adds a
-loose vertex so the mesh-hygiene budget fails. ``--lift-z`` raises the
-mesh so the grounded-zmin budget fails. ``--float-crank`` offsets the
-crank from the axle so joint-fit fails. ``--no-dip`` raises the stone
-clear of the trough so the seat-conformance dip band fails.
-``--short-legs`` raises the iron shoes and plants a dummy so the named
-support budget fails while AABB zmin still passes. ``--float-legs``
-lifts the A-frame timber off the shoes so the shoe-wood join fails.
-``--narrow-trough`` shrinks the tub so it no longer seats in the sills.
-
-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.
+loose vertex so the mesh-hygiene budget fails. ``--flush-shoes`` sizes
+the iron shoes to the sill so their faces share its planes and the
+coplanar budget fails. ``--lift-z`` raises the mesh so the
+grounded-zmin budget fails. ``--short-legs`` raises the iron shoes and
+plants a dummy so the named support budget fails while AABB zmin still
+passes. ``--float-crank`` offsets the crank from the axle so joint-fit
+fails. ``--float-legs`` lifts the A-frame timber off the shoes so the
+shoe-wood join fails. ``--narrow-trough`` shrinks the tub so it no
+longer seats in the sills. ``--no-dip`` raises the stone clear of the
+trough so the seat-conformance dip band fails. ``--low-stretchers``
+drops the end stretchers under the trough so it no longer bears on
+them. ``--sharp-handle`` leaves the crank handle unchamfered so the
+edge-treatment budget fails. ``--low-bake`` bakes at 256 px so the
+texel-density budget fails.
+
+Seeded, not random: per-member tone uses ``random.Random(TONE_SEED)``.
+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.
 
     blender --background --python grindstone.py --
     blender --background --python grindstone.py -- --skip-decimate
@@ -29,6 +36,7 @@
 import argparse
 import math
 import os
+import random
 import sys
 import tempfile
 import traceback
@@ -37,6 +45,7 @@
 import bpy
 from mathutils import Euler, Vector
 from mathutils.bvhtree import BVHTree
+from mathutils.kdtree import KDTree
 
 _REPO = os.path.abspath(
     os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir, os.pardir)
@@ -47,7 +56,10 @@
 
 STONE_R = 0.250
 STONE_T = 0.095
-STONE_SEGS = 32
+# 32 flat-shaded segments read as a polygon in the front orthographic and
+# threw one highlight per facet across the tread. 48 smooth segments with
+# hard chamfer rings read as a turned wheel.
+STONE_SEGS = 48
 CHAMFER = 0.012
 TROUGH_H = 0.080
 TROUGH_WALL = 0.018
@@ -62,7 +74,13 @@
 # tenon *into* the frame. Matching Y-thickness puts coplanar faces
 # on the camera side and reads as a black hole in the timber.
 SILL_Y = 0.070
+KING_X = 0.052
 KING_Y = 0.054
+# Each diagonal tenons into the king post's face by a named bite. Run to
+# the king's centre line, the pair met at one apex and their chamfered
+# end faces landed on each other inside the bearing: 6 coplanar pairs.
+DIAG_BITE = 0.012
+SILL_END = LEG_SPREAD + 0.035
 # Seat the tub into the sill inner faces. Deriving from LEG_XY left a
 # daylight slot once the sill was fattened to nest the diagonals.
 TROUGH_SEAT = 0.012
@@ -74,15 +92,39 @@
 CRANK_ARM = 0.13
 HANDLE_L = 0.11
 SHOE_H = 0.024
-SHOE_XY = (0.070, 0.070)
+# An iron shoe is a cup round the sill's end, a named reveal proud of it
+# on every side. The first build made it exactly as wide as the sill and
+# flush with its end, so the two shared three planes per foot: a lit slit
+# in every foot close-up, which a centre-coincidence z-fight test missed.
+SHOE_REVEAL = 0.006
+SHOE_CUP = 0.064
+# The end stretchers carry the trough: their top is the trough's bottom
+# plus a named bite. At sill height they stopped 6 mm short, a dark slit
+# under the tub. Stationed inboard of the shoes, so a stretcher is never
+# the wood a shoe measures against.
+STRETCH_W = 0.038
+STRETCH_H = 0.035
+STRETCH_CLEAR = 0.010
+TROUGH_BITE = 0.004
+TROUGH_BITE_MIN = 0.002
+TROUGH_BITE_MAX = 0.008
+IRON_BEVEL = 0.0012
+BEVEL_MIN_ANGLE = math.radians(50.0)
+PLANK_TONE_JITTER = 0.26
+TONE_SEED = 43
+WOOD_GRAIN_SCALE = 30.0
 
 BBOX_TOL = 0.015
-OUTER_SIZE = (0.710, 0.419, 0.610)
+# Shoes one reveal past the sill ends (X); the crank handle (Y); the
+# stone's crown (Z). X was 0.710 with flush shoes.
+OUTER_SIZE = (0.722, 0.419, 0.610)
 STONE_DIA = 2.0 * STONE_R
 STONE_DIA_TOL = 0.02
 STONE_T_TOL = 0.015
-BASE_TRIS_MIN = 700
-BASE_TRIS_MAX = 1000
+# Re-fitted for the rebuild (928 -> 1668: chamfers on every member, a
+# 48-segment stone). Centred on the measurement.
+BASE_TRIS_MIN = 1560
+BASE_TRIS_MAX = 1780
 LOD1_RATIO_MIN = 0.32
 LOD1_RATIO_MAX = 0.62
 LOD2_RATIO_MIN = 0.10
@@ -92,17 +134,32 @@
 MATERIAL_COUNT = 3
 UV_EPS = 1e-4
 UV_OVERLAP_MAX = 1e-5
-COLLIDER_TRIS_MAX = 240
-BAKE_RES = 256
-CAGE_EXTRUSION = 0.08
-METAL_FACES_MIN = 80
-WOOD_FACES_MIN = 80
-STONE_FACES_MIN = 80
+# Re-fitted: the 48-segment stone adds hull vertices (198 -> 304).
+COLLIDER_TRIS_MAX = 320
+# One UV cell per face; 256 px left each cell under 12 texels, so the
+# bilinear lookup read neighbouring cells' normals (tavern-stool's defect).
+BAKE_RES = 1024
+LOW_BAKE_RES = 256
+TEXEL_MIN = 12.0
+# The cage covers the chamfer difference between high and low (under
+# 2 mm); a wide one reaches the next part and bakes its surface instead.
+CAGE_EXTRUSION = 0.01
+# About 70% of each measured count; the first build's 80 apiece let most
+# of a material's faces go missing unseen.
+METAL_FACES_MIN = 260
+WOOD_FACES_MIN = 280
+STONE_FACES_MIN = 190
 ZMIN_EPS = 1e-4
 DOUBLES_EPS = 1e-5
 AREA_EPS = 1e-10
-ZFIGHT_EPS = 1e-4
-ZFIGHT_COS = 0.999
+# Z-fighting: two separate bodies landing on one plane. Cross-shell, with
+# hay-bale's constants (copied, not imported). The first build matched
+# only faces whose centres fell within 0.1 mm of each other, which no
+# real shoe-on-sill overlap ever does.
+COPLANAR_NORMAL_EPS = 1e-4
+COPLANAR_PLANE_EPS = 1e-4
+COPLANAR_CENTRE_MAX = 0.05
+ZFIGHT_PAIRS_MAX = 0
 LIFT_Z = 0.05
 CRANK_JOIN = 0.008
 SHOE_JOIN = 0.008
@@ -111,6 +168,10 @@
 DIP_MAX = 0.045
 SHOE_Z_MAX = 1e-3
 TROUGH_FLOOR_Z_MIN = 0.040
+# Edge treatment: every timber and iron edge is chamfered, so a manifold
+# edge still within RIGHT_ANGLE_TOL of 90 degrees is a skipped bevel.
+RIGHT_ANGLE_TOL = math.radians(5.0)
+RIGHT_ANGLE_MAX = 0
 
 WOOD_IDX = 0
 STONE_IDX = 1
@@ -163,6 +224,13 @@ def add_box(bm, loc, scale, mat_idx, euler=(0.0, 0.0, 0.0)):
     return verts
 
 
+def add_span(bm, lo, hi, mat_idx):
+    """Axis-aligned box from its min corner to its max corner."""
+    lo = Vector(lo)
+    hi = Vector(hi)
+    return add_box(bm, (lo + hi) * 0.5, hi - lo, mat_idx)
+
+
 def add_oriented_box(bm, a, b, scale_xy, mat_idx):
     a = Vector(a)
     b = Vector(b)
@@ -182,10 +250,12 @@ def add_oriented_box(bm, a, b, scale_xy, mat_idx):
 
 
 def add_cyl(bm, loc, radius, depth, segments, mat_idx, euler=(0.0, 0.0, 0.0)):
+    """Cylinder with n-gon caps; ``finish_caps`` triangulates them after the
+    chamfer pass, which folds a chamfered triangle-fan cap inside out."""
     geo = bmesh.ops.create_cone(
         bm,
         cap_ends=True,
-        cap_tris=True,
+        cap_tris=False,
         segments=segments,
         radius1=radius,
         radius2=radius,
@@ -202,6 +272,15 @@ def add_cyl(bm, loc, radius, depth, segments, mat_idx, euler=(0.0, 0.0, 0.0)):
     return verts
 
 
+def finish_caps(bm):
+    """Triangulate every face with more than four corners."""
+    ngons = [f for f in bm.faces if len(f.verts) > 4]
+    if ngons:
+        bmesh.ops.triangulate(
+            bm, faces=ngons, quad_method="BEAUTY", ngon_method="BEAUTY",
+        )
+
+
 def add_basin(bm, loc, size, wall, mat_idx):
     """One manifold open tub. Five overlapping boxes bevel into degenerates."""
     geo = bmesh.ops.create_cube(bm, size=1.0)
@@ -327,7 +406,8 @@ def pack_uvs(bm, margin=0.08):
 def build_grindstone_mesh(
     name, bevel_offset, bevel_segments,
     float_crank=False, no_dip=False, short_legs=False, float_legs=False,
-    narrow_trough=False,
+    narrow_trough=False, flush_shoes=False, low_stretchers=False,
+    sharp_handle=False,
 ):
     bm = bmesh.new()
     try:
@@ -346,22 +426,20 @@ def build_grindstone_mesh(
         shoe_z = 0.05 if short_legs else 0.0
         bearing_h = 0.090
         bearing_xz = (0.078, bearing_h)
-        king_xy = (0.052, KING_Y)
-        # Diagonals *are* the legs. A tall stump beside an angled timber
-        # paints a see-through triangle on the stump face. Bury a short
-        # tenon in the shoe (never proud of the iron) and start the
-        # diagonal on the shoe top so the angled end-cap cannot pierce
-        # Z=0.
-        tenon_z = shoe_z + SHOE_H * 0.50
+        king_xy = (KING_X, KING_Y)
+        # Diagonals *are* the legs, and they start in the sill above the
+        # shoe so the angled end-cap cannot pierce Z=0. The first build
+        # also buried a short tenon box in each shoe, wholly hidden inside
+        # sill and iron: triangles nobody could see.
         diag_z = shoe_z + SHOE_H + 0.008
         if float_legs:
-            tenon_z = shoe_z + SHOE_H + 0.070
             diag_z = shoe_z + SHOE_H + 0.070
         sill_h = 0.050
         sill_bottom = (
             shoe_z + SHOE_H + 0.055 if float_legs else shoe_z + SHOE_H * 0.40
         )
         sill_z = sill_bottom + sill_h / 2.0
+        reveal = 0.0 if flush_shoes else SHOE_REVEAL
 
         for y in (-FRAME_Y, FRAME_Y):
             # King post fills the A-crotch so the bearing is not a cube
@@ -383,57 +461,52 @@ def build_grindstone_mesh(
                     WOOD_IDX,
                 )
             )
-            # Tie beam sits on the shoes and occupies the A-foot.
+            # Tie beam sits in the shoes and occupies the A-foot.
             wood.extend(
-                add_box(
+                add_span(
                     bm,
-                    (0.0, y, sill_z),
-                    (LEG_SPREAD * 2.0 + SHOE_XY[0], SILL_Y, sill_h),
+                    (-SILL_END, y - SILL_Y / 2.0, sill_bottom),
+                    (SILL_END, y + SILL_Y / 2.0, sill_bottom + sill_h),
                     WOOD_IDX,
                 )
             )
-            for x in (-LEG_SPREAD, LEG_SPREAD):
-                if not float_legs:
-                    wood.extend(
-                        add_box(
-                            bm,
-                            (x, y, tenon_z),
-                            (LEG_XY[0] * 0.92, LEG_XY[1] * 0.92, SHOE_H * 0.90),
-                            WOOD_IDX,
-                        )
-                    )
+            for s in (-1.0, 1.0):
                 wood.extend(
                     add_oriented_box(
                         bm,
-                        (x, y, diag_z),
-                        (0.0, y, axle_z - 0.010),
+                        (s * LEG_SPREAD, y, diag_z),
+                        (s * (KING_X / 2.0 - DIAG_BITE), y, axle_z - 0.010),
                         LEG_XY,
                         WOOD_IDX,
                     )
                 )
+                x_in, x_out = SILL_END - SHOE_CUP, SILL_END + reveal
                 metal.extend(
-                    add_box(
+                    add_span(
                         bm,
-                        (x, y, shoe_z + SHOE_H / 2.0),
-                        (SHOE_XY[0], SHOE_XY[1], SHOE_H),
+                        (min(s * x_in, s * x_out), y - SILL_Y / 2.0 - reveal, shoe_z),
+                        (max(s * x_in, s * x_out), y + SILL_Y / 2.0 + reveal,
+                         shoe_z + SHOE_H),
                         METAL_IDX,
                     )
                 )
 
-        for x in (-LEG_SPREAD, LEG_SPREAD):
-            # End stretchers tenon through both sills at sill height.
-            # A higher independent Z left them floating as extra cubes.
+        # End stretchers tenon through both sills and carry the trough.
+        stretch_top = TROUGH_Z0 + TROUGH_BITE
+        if low_stretchers:
+            stretch_top = sill_z + sill_h * 0.35
+        stretch_x = SILL_END - SHOE_CUP - STRETCH_CLEAR - STRETCH_W / 2.0
+        for s in (-1.0, 1.0):
             wood.extend(
-                add_box(
+                add_span(
                     bm,
-                    (x, 0.0, sill_z),
-                    (0.038, FRAME_Y * 2.0, sill_h * 0.70),
+                    (s * stretch_x - STRETCH_W / 2.0, -FRAME_Y, stretch_top - STRETCH_H),
+                    (s * stretch_x + STRETCH_W / 2.0, FRAME_Y, stretch_top),
                     WOOD_IDX,
                 )
             )
 
         tw = TROUGH_W * (0.58 if narrow_trough else 1.0)
-        chamfer = []
         basin_verts = add_basin(
             bm,
             (0.0, 0.0, tub_z0 + TROUGH_H / 2.0),
@@ -441,9 +514,9 @@ def build_grindstone_mesh(
             TROUGH_WALL,
             WOOD_IDX,
         )
-        chamfer.extend(basin_verts)
+        wood.extend(basin_verts)
 
-        chamfer.extend(
+        handle = set(
             add_cyl(
                 bm,
                 (0.0, crank_y + HANDLE_L * 0.15, axle_z + CRANK_ARM),
@@ -454,7 +527,7 @@ def build_grindstone_mesh(
                 euler=(math.pi / 2.0, 0.0, 0.0),
             )
         )
-        wood.extend(chamfer)
+        wood.extend(handle)
 
         add_stone(bm, (0.0, 0.0), axle_z)
 
@@ -519,44 +592,110 @@ def build_grindstone_mesh(
             v.co.x -= cx
             v.co.y -= cy
 
+        bm.edges.index_update()
+
+        def sharp(edge, idx):
+            if len(edge.link_faces) != 2:
+                return False
+            if any(f.material_index != idx for f in edge.link_faces):
+                return False
+            # --sharp-handle leaves the crank handle's rims square: a few
+            # dozen triangles short, inside the triangle band, so only
+            # the edge budget can see it.
+            if sharp_handle and all(v in handle for v in edge.verts):
+                return False
+            return edge.calc_face_angle(0.0) > BEVEL_MIN_ANGLE
+
         if bevel_offset > 0.0:
-            edges = []
-            trough_verts = set(basin_verts)
-            for e in {e for v in trough_verts for e in v.link_edges}:
-                if min(v.co.z for v in e.verts) < tub_z0 - 0.002:
-                    continue
-                if any(f.material_index != WOOD_IDX for f in e.link_faces):
-                    continue
-                edges.append(e)
-            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 = WOOD_IDX
+            edges = sorted(
+                (e for e in bm.edges if sharp(e, WOOD_IDX)), key=lambda e: e.index
+            )
+            bmesh.ops.bevel(
+                bm, geom=edges, offset=bevel_offset, segments=bevel_segments,
+                profile=0.5, affect="EDGES", clamp_overlap=True, material=WOOD_IDX,
+            )
+            bm.edges.index_update()
+            edges = sorted(
+                (e for e in bm.edges if sharp(e, METAL_IDX)), key=lambda e: e.index
+            )
+            bmesh.ops.bevel(
+                bm, geom=edges, offset=IRON_BEVEL, segments=1, profile=0.5,
+                affect="EDGES", clamp_overlap=True, material=METAL_IDX,
+            )
+        finish_caps(bm)
 
         pack_uvs(bm)
         bmesh.ops.recalc_face_normals(bm, faces=list(bm.faces))
+        # Smooth across the stone's and the round irons' facets; hard at
+        # every chamfer and material boundary. The stone's chamfer rings
+        # meet its tread at 32 degrees, so its threshold is lower.
         for face in bm.faces:
-            face.smooth = False
+            face.smooth = True
+        for edge in bm.edges:
+            edge.smooth = True
+            if len(edge.link_faces) == 2:
+                f0, f1 = edge.link_faces
+                limit = math.radians(
+                    25.0 if f0.material_index == STONE_IDX else 35.0
+                )
+                if (f0.material_index != f1.material_index
+                        or edge.calc_face_angle(0.0) > limit):
+                    edge.smooth = False
         me = bpy.data.meshes.new(name)
         bm.to_mesh(me)
         me.update()
-        for poly in me.polygons:
-            poly.use_smooth = False
     finally:
         bm.free()
+    paint_planks(me)
     out = bpy.data.objects.new(name, me)
     bpy.context.collection.objects.link(out)
     return out
 
 
+def _long_axis(pts):
+    """Principal axis of a point set, by power iteration on its covariance."""
+    c = sum(pts, Vector()) / len(pts)
+    cov = [[0.0] * 3 for _ in range(3)]
+    for p in pts:
+        d = p - c
+        for i in range(3):
+            for j in range(3):
+                cov[i][j] += d[i] * d[j]
+    v = Vector((1.0, 0.3, 0.1))
+    for _ in range(30):
+        w = Vector([sum(cov[i][j] * v[j] for j in range(3)) for i in range(3)])
+        if w.length < 1e-12:
+            break
+        v = w.normalized()
+    return v
+
+
+def paint_planks(me):
+    """Per-shell ``PlankTone`` and ``GrainDir`` face attributes for the wood shader.
+
+    Every sill, diagonal, king, bearing and stretcher is its own shell, so
+    each gets one seeded tone and grain along its own long axis.
+    """
+    tone = [0.5] * len(me.polygons)
+    grain = [(0.0, 0.0, 1.0)] * len(me.polygons)
+    owner = {}
+    rng = random.Random(TONE_SEED)
+    for g in sorted(shells(me), key=min):
+        pts = [me.vertices[i].co.copy() for i in g]
+        d = _long_axis(pts) if len(pts) > 2 else Vector((0.0, 0.0, 1.0))
+        t = 0.5 + rng.uniform(-PLANK_TONE_JITTER, PLANK_TONE_JITTER)
+        for i in g:
+            owner[i] = (t, tuple(d))
+    for poly in me.polygons:
+        t, d = owner[poly.vertices[0]]
+        tone[poly.index] = t
+        grain[poly.index] = d
+    a = me.attributes.new("PlankTone", "FLOAT", "FACE")
+    a.data.foreach_set("value", tone)
+    b = me.attributes.new("GrainDir", "FLOAT_VECTOR", "FACE")
+    b.data.foreach_set("vector", [c for v in grain for c in v])
+
+
 def principled(name, color, metallic, roughness, noise_scale=0.0, wear=None):
     mat = bpy.data.materials.new(name)
     mat.use_nodes = True
@@ -587,6 +726,136 @@ def principled(name, color, metallic, roughness, noise_scale=0.0, wear=None):
     return mat
 
 
+def _sock(sockets, identifier):
+    """A Mix-node socket by identifier; its A/B/Result names repeat per type."""
+    return next(sk for sk in sockets if sk.identifier == identifier)
+
+
+def wood_material(name):
+    """Grain along each member (``GrainDir``), tone per member (``PlankTone``).
+
+    Copied from showcase/wheelbarrow (do not import across pieces).
+    """
+    mat = bpy.data.materials.new(name)
+    mat.use_nodes = True
+    nt = mat.node_tree
+    bsdf = nt.nodes["Principled BSDF"]
+    coord = nt.nodes.new("ShaderNodeTexCoord")
+    gdir = nt.nodes.new("ShaderNodeAttribute")
+    gdir.attribute_name = "GrainDir"
+    tone = nt.nodes.new("ShaderNodeAttribute")
+    tone.attribute_name = "PlankTone"
+    dot = nt.nodes.new("ShaderNodeVectorMath")
+    dot.operation = "DOT_PRODUCT"
+    nt.links.new(coord.outputs["Object"], dot.inputs[0])
+    nt.links.new(gdir.outputs["Vector"], dot.inputs[1])
+    squash = nt.nodes.new("ShaderNodeMath")
+    squash.operation = "MULTIPLY"
+    squash.inputs[1].default_value = 0.94
+    nt.links.new(dot.outputs["Value"], squash.inputs[0])
+    along = nt.nodes.new("ShaderNodeVectorMath")
+    along.operation = "SCALE"
+    nt.links.new(gdir.outputs["Vector"], along.inputs[0])
+    nt.links.new(squash.outputs["Value"], along.inputs["Scale"])
+    grain_co = nt.nodes.new("ShaderNodeVectorMath")
+    grain_co.operation = "SUBTRACT"
+    nt.links.new(coord.outputs["Object"], grain_co.inputs[0])
+    nt.links.new(along.outputs["Vector"], grain_co.inputs[1])
+    shift = nt.nodes.new("ShaderNodeVectorMath")
+    shift.operation = "ADD"
+    nt.links.new(grain_co.outputs["Vector"], shift.inputs[0])
+    nt.links.new(tone.outputs["Fac"], shift.inputs[1])
+    noise = nt.nodes.new("ShaderNodeTexNoise")
+    noise.inputs["Scale"].default_value = WOOD_GRAIN_SCALE
+    noise.inputs["Detail"].default_value = 6.0
+    noise.inputs["Roughness"].default_value = 0.62
+    nt.links.new(shift.outputs["Vector"], noise.inputs["Vector"])
+    ramp = nt.nodes.new("ShaderNodeValToRGB")
+    ramp.color_ramp.elements[0].position = 0.30
+    ramp.color_ramp.elements[0].color = (0.12, 0.052, 0.018, 1.0)
+    ramp.color_ramp.elements[1].position = 0.72
+    ramp.color_ramp.elements[1].color = (0.38, 0.18, 0.065, 1.0)
+    nt.links.new(noise.outputs["Fac"], ramp.inputs["Fac"])
+    gain = nt.nodes.new("ShaderNodeMath")
+    gain.operation = "MULTIPLY_ADD"
+    gain.inputs[1].default_value = 1.1
+    gain.inputs[2].default_value = 0.45
+    nt.links.new(tone.outputs["Fac"], gain.inputs[0])
+    mix = nt.nodes.new("ShaderNodeMix")
+    mix.data_type = "RGBA"
+    mix.blend_type = "MULTIPLY"
+    _sock(mix.inputs, "Factor_Float").default_value = 1.0
+    nt.links.new(ramp.outputs["Color"], _sock(mix.inputs, "A_Color"))
+    nt.links.new(gain.outputs["Value"], _sock(mix.inputs, "B_Color"))
+    nt.links.new(_sock(mix.outputs, "Result_Color"), bsdf.inputs["Base Color"])
+    rough = nt.nodes.new("ShaderNodeMapRange")
+    rough.inputs["To Min"].default_value = 0.72
+    rough.inputs["To Max"].default_value = 0.52
+    nt.links.new(noise.outputs["Fac"], rough.inputs["Value"])
+    nt.links.new(rough.outputs["Result"], bsdf.inputs["Roughness"])
+    return mat
+
+
+def stone_material(name):
+    """Sandstone: isotropic object-space mottling, fine speckle driving
+    roughness and a small bump. The first build's pale noise mix rendered
+    the wheel chalk-white, a plastic disc rather than a quarried stone.
+    """
+    mat = bpy.data.materials.new(name)
+    mat.use_nodes = True
+    nt = mat.node_tree
+    bsdf = nt.nodes["Principled BSDF"]
+    coord = nt.nodes.new("ShaderNodeTexCoord")
+    mottle = nt.nodes.new("ShaderNodeTexNoise")
+    mottle.inputs["Scale"].default_value = 7.0
+    mottle.inputs["Detail"].default_value = 5.0
+    mottle.inputs["Roughness"].default_value = 0.6
+    nt.links.new(coord.outputs["Object"], mottle.inputs["Vector"])
+    ramp = nt.nodes.new("ShaderNodeValToRGB")
+    ramp.color_ramp.elements[0].position = 0.32
+    ramp.color_ramp.elements[0].color = (0.20, 0.16, 0.115, 1.0)
+    ramp.color_ramp.elements[1].position = 0.70
+    ramp.color_ramp.elements[1].color = (0.34, 0.28, 0.20, 1.0)
+    nt.links.new(mottle.outputs["Fac"], ramp.inputs["Fac"])
+    speck = nt.nodes.new("ShaderNodeTexNoise")
+    speck.inputs["Scale"].default_value = 220.0
+    speck.inputs["Detail"].default_value = 2.0
+    nt.links.new(coord.outputs["Object"], speck.inputs["Vector"])
+    grit = nt.nodes.new("ShaderNodeMix")
+    grit.data_type = "RGBA"
+    grit.blend_type = "MULTIPLY"
+    _sock(grit.inputs, "Factor_Float").default_value = 0.35
+    nt.links.new(ramp.outputs["Color"], _sock(grit.inputs, "A_Color"))
+    nt.links.new(speck.outputs["Color"], _sock(grit.inputs, "B_Color"))
+    nt.links.new(_sock(grit.outputs, "Result_Color"), bsdf.inputs["Base Color"])
+    rough = nt.nodes.new("ShaderNodeMapRange")
+    rough.inputs["To Min"].default_value = 0.80
+    rough.inputs["To Max"].default_value = 0.96
+    nt.links.new(speck.outputs["Fac"], rough.inputs["Value"])
+    nt.links.new(rough.outputs["Result"], bsdf.inputs["Roughness"])
+    bump = nt.nodes.new("ShaderNodeBump")
+    bump.inputs["Strength"].default_value = 0.18
+    bump.inputs["Distance"].default_value = 0.002
+    nt.links.new(speck.outputs["Fac"], bump.inputs["Height"])
+    nt.links.new(bump.outputs["Normal"], bsdf.inputs["Normal"])
+    return mat
+
+
+def grindstone_materials():
+    """(wood, stone, iron): shared by the check, the render and inspection.
+
+    Forged iron is dark and rusted. The first build's metallic 1.0 at 0.38
+    roughness rendered hubs and shoes as black plastic.
+    """
+    wood = wood_material("GrindstoneWood")
+    stone = stone_material("GrindstoneStone")
+    metal = principled(
+        "GrindstoneIron", (0.17, 0.165, 0.155, 1.0), 0.80, 0.46,
+        noise_scale=18.0, wear=(0.20, 0.085, 0.032, 1.0),
+    )
+    return wood, stone, metal
+
+
 def assign_slots(obj, wood, stone, metal):
     mats = obj.data.materials
     wanted = (wood, stone, metal)
@@ -665,24 +934,39 @@ def hygiene_audit(me):
 
 
 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:
+    """Coplanar face pairs from *different shells* — the z-fighting budget.
+
+    Cross-shell, not merely share-no-vertex: two quads on one flat face of
+    a chamfered box share no vertex and are coplanar by construction.
+    Z-fighting is two separate bodies landing on one plane. Combinatorics
+    and constants copied from showcase/hay-bale (do not import across
+    pieces); candidate pairs come from a KD-tree range query at
+    COPLANAR_CENTRE_MAX.
+    """
+    owner = {}
+    for si, g in enumerate(shells(me)):
+        for vi in g:
+            owner[vi] = si
+    faces = [(p.normal.copy(), p.center.copy(), owner.get(p.vertices[0], -1))
+             for p in me.polygons]
+    kd = KDTree(len(faces))
+    for i, (_n, c, _s) in enumerate(faces):
+        kd.insert(c, i)
+    kd.balance()
+    hits = 0
+    for i, (ni, ci, si) in enumerate(faces):
+        for _co, j, _d in kd.find_range(ci, COPLANAR_CENTRE_MAX):
+            if j <= i:
+                continue
+            nj, cj, sj = faces[j]
+            if si == sj:
                 continue
-            if abs(ni.dot(nj)) <= ZFIGHT_COS:
+            if abs(abs(ni.dot(nj)) - 1.0) > COPLANAR_NORMAL_EPS:
                 continue
-            if vi & vj:
+            if abs(ni.dot(cj - ci)) > COPLANAR_PLANE_EPS:
                 continue
-            count += 1
-    return count
+            hits += 1
+    return hits
 
 
 def shells(me):
@@ -753,6 +1037,17 @@ def trough_floor_z(me):
     return best
 
 
+def _trough_box(me, groups):
+    for g in groups:
+        if mat_of(me, g) != WOOD_IDX:
+            continue
+        a = shell_aabb(me, g)
+        dx, dy = a[3] - a[0], a[4] - a[1]
+        if abs(dx - TROUGH_L) < 0.08 and dy > 0.08 and a[2] < 0.15:
+            return a
+    return None
+
+
 def stone_audit(me):
     stone_pts = []
     groups = shells(me)
@@ -770,15 +1065,7 @@ def stone_audit(me):
     dia = max(max(xs) - min(xs), max(zs) - min(zs))
     thick = max(ys) - min(ys)
     zmin = min(zs)
-    tb = None
-    for g in groups:
-        if mat_of(me, g) != WOOD_IDX:
-            continue
-        a = shell_aabb(me, g)
-        dx, dy = a[3] - a[0], a[4] - a[1]
-        if abs(dx - TROUGH_L) < 0.08 and dy > 0.08 and a[2] < 0.15:
-            tb = a
-            break
+    tb = _trough_box(me, groups)
     trough_z = tb[2] if tb else trough_floor_z(me)
     trough_top = tb[5] if tb else (TROUGH_Z0 + TROUGH_H)
     return {
@@ -790,6 +1077,28 @@ def stone_audit(me):
     }
 
 
+def trough_bearing(me):
+    """How deep the trough's floor bites each end stretcher.
+
+    Stretchers are the wood shells that cross the frame in Y and are
+    short in X and Z, read off the mesh and counted, so a dropped
+    stretcher cannot pass vacuously. A trough resting a few millimetres
+    above its bearers passes the sill seat and the dip band; this is the
+    budget that sees the slit.
+    """
+    groups = shells(me)
+    tb = _trough_box(me, groups)
+    bites = []
+    for g in groups:
+        if mat_of(me, g) != WOOD_IDX:
+            continue
+        a = shell_aabb(me, g)
+        dx, dy, dz = a[3] - a[0], a[4] - a[1], a[5] - a[2]
+        if dx < 0.06 and dy > 1.5 * FRAME_Y and dz < 0.05:
+            bites.append(a[5] - tb[2] if tb else -1.0)
+    return bites
+
+
 def crank_join(me):
     """Gap from crank-arm verts to the axle shell."""
     groups = shells(me)
@@ -913,6 +1222,47 @@ def shoe_wood_gap(me):
         bm_wood.free()
 
 
+def right_angle_edges(me):
+    """Manifold edges whose two faces meet at 90 degrees, iron and timber.
+
+    Every box and cylinder in the piece is chamfered, and a chamfer turns
+    a 90-degree edge into two shallower ones. An edge still at 90 is one a
+    bevel pass skipped: the razor edge that renders as a hard black line.
+    Copied from showcase/crate-stack (do not import across pieces).
+    """
+    counts = {WOOD_IDX: 0, STONE_IDX: 0, METAL_IDX: 0}
+    bm = bmesh.new()
+    try:
+        bm.from_mesh(me)
+        for e in bm.edges:
+            if len(e.link_faces) != 2:
+                continue
+            if abs(e.calc_face_angle(0.0) - math.pi / 2.0) <= RIGHT_ANGLE_TOL:
+                idx = e.link_faces[0].material_index
+                counts[idx] = counts.get(idx, 0) + 1
+    finally:
+        bm.free()
+    return counts
+
+
+def texel_audit(mesh, img):
+    """Smallest UV cell, in baked texels along its longer side.
+
+    Copied from showcase/tavern-stool (do not import across pieces).
+    """
+    uv = mesh.uv_layers.active
+    if uv is None or img is None:
+        return 0.0
+    res = min(img.size[0], img.size[1])
+    data = uv.data
+    worst = 1e9
+    for poly in mesh.polygons:
+        us = [data[i].uv[0] for i in poly.loop_indices]
+        vs = [data[i].uv[1] for i in poly.loop_indices]
+        worst = min(worst, max(max(us) - min(us), max(vs) - min(vs)) * res)
+    return worst
+
+
 def add_stray_vert(me):
     bm = bmesh.new()
     try:
@@ -1010,31 +1360,26 @@ def export_unity(path, objects):
     )
 
 
+def _no():
+    return None, None, None, None, None
+
+
 def check(
     skip_decimate, lift_z=False, stray_vert=False,
     float_crank=False, no_dip=False, short_legs=False, float_legs=False,
-    narrow_trough=False,
+    narrow_trough=False, flush_shoes=False, low_stretchers=False,
+    sharp_handle=False, low_bake=False,
 ):
     bpy.ops.wm.read_factory_settings(use_empty=True)
     flags = dict(
         float_crank=float_crank, no_dip=no_dip,
         short_legs=short_legs, float_legs=float_legs,
-        narrow_trough=narrow_trough,
-    )
-    low = build_grindstone_mesh("GrindstoneLow", 0.004, 2, **flags)
-    high = build_grindstone_mesh("GrindstoneHigh", 0.004, 4, **flags)
-    wood = principled(
-        "GrindstoneWood", (0.38, 0.20, 0.08, 1.0), 0.0, 0.62,
-        noise_scale=6.5, wear=(0.22, 0.11, 0.04, 1.0),
-    )
-    stone = principled(
-        "GrindstoneStone", (0.40, 0.36, 0.30, 1.0), 0.0, 0.92,
-        noise_scale=14.0, wear=(0.28, 0.24, 0.18, 1.0),
-    )
-    metal = principled(
-        "GrindstoneIron", (0.14, 0.145, 0.155, 1.0), 1.0, 0.38,
-        noise_scale=5.0, wear=(0.05, 0.05, 0.06, 1.0),
+        narrow_trough=narrow_trough, flush_shoes=flush_shoes,
+        low_stretchers=low_stretchers, sharp_handle=sharp_handle,
     )
+    low = build_grindstone_mesh("GrindstoneLow", 0.004, 1, **flags)
+    high = build_grindstone_mesh("GrindstoneHigh", 0.004, 3, **flags)
+    wood, stone, metal = grindstone_materials()
     assign_slots(low, wood, stone, metal)
     assign_slots(high, wood, stone, metal)
     if stray_vert:
@@ -1046,7 +1391,7 @@ def check(
         bpy.context.view_layer.update()
 
     if low.data is None or len(low.data.polygons) < 6:
-        return fail("grindstone mesh did not build", 3), None, None, None, None, None
+        return (fail("grindstone mesh did not build", 3),) + _no()
 
     base_tris = triangle_count(low.data)
     mats = [s for s in low.data.materials if s is not None]
@@ -1062,10 +1407,11 @@ def check(
     size_y = bb[4] - bb[1]
     size_z = bb[5] - bb[2]
 
-    img, tex = setup_bake_image(low, stone)
+    img, tex = setup_bake_image(low, stone, LOW_BAKE_RES if low_bake else BAKE_RES)
     if img is None:
-        return fail("grindstone has no UV layer", 3), None, None, None, None, None
+        return (fail("grindstone has no UV layer", 3),) + _no()
     bake_result = bake_normal(high, low)
+    texel = texel_audit(low.data, img)
 
     lod1 = make_lod(low, "GrindstoneLOD1", LOD1_TARGET, skip_decimate)
     lod2 = make_lod(low, "GrindstoneLOD2", LOD2_TARGET, skip_decimate)
@@ -1088,6 +1434,11 @@ def check(
         os.remove(export_path)
     export_unity(export_path, [low, collider])
     export_size = os.path.getsize(export_path) if os.path.isfile(export_path) else 0
+    if os.path.isfile(export_path):
+        try:
+            os.remove(export_path)
+        except OSError:
+            pass
 
     hyg = hygiene_audit(low.data)
     zf = zfight_pairs(low.data)
@@ -1096,6 +1447,11 @@ def check(
     cj = crank_join(low.data)
     sw = shoe_wood_gap(low.data)
     ts = trough_sill_gap(low.data)
+    bites = trough_bearing(low.data)
+    right_angles = right_angle_edges(low.data)
+    n_right_angles = sum(right_angles.values())
+    bite_lo = min(bites) if bites else -1.0
+    bite_hi = max(bites) if bites else 1e9
 
     print(f"blender={tuple(bpy.app.version)} skip_decimate={skip_decimate}")
     print(
@@ -1112,7 +1468,8 @@ def check(
     )
     print(
         f"measured collider_tris={col_tris} bake={bake_result} "
-        f"bake_has_data={img.has_data} export_bytes={export_size}"
+        f"bake_has_data={img.has_data} export_bytes={export_size} "
+        f"bake_res={img.size[0]} texel_min={texel:.2f}"
     )
     print(
         f"measured hygiene loose_v={hyg['loose_v']} loose_e={hyg['loose_e']} "
@@ -1125,152 +1482,162 @@ def check(
         f"dip={st['dip']:.5f} trough_z={st['trough_z']:.5f} "
         f"crank_join={cj:.5f} shoe_wood={sw:.5f} trough_sill={ts:.5f}"
     )
+    print(
+        f"measured trough_bearing={len(bites)} stretchers "
+        f"bite=[{bite_lo:.5f},{bite_hi:.5f}] right_angle_edges={right_angles}"
+    )
 
     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}]",
-            4,
-        ), None, None, None, None, None
+        return (fail(
+            f"base tris {base_tris} not in [{BASE_TRIS_MIN}, {BASE_TRIS_MAX}]", 4,
+        ),) + _no()
     if nmat != MATERIAL_COUNT or distinct_mats != MATERIAL_COUNT:
-        return fail(
-            f"material slots {nmat} distinct {distinct_mats} != {MATERIAL_COUNT}",
-            5,
-        ), None, None, None, None, None
+        return (fail(
+            f"material slots {nmat} distinct {distinct_mats} != {MATERIAL_COUNT}", 5,
+        ),) + _no()
     if idx_counts.get(METAL_IDX, 0) < METAL_FACES_MIN:
-        return fail(
-            f"metal faces {idx_counts.get(METAL_IDX, 0)} < {METAL_FACES_MIN}",
-            5,
-        ), None, None, None, None, None
+        return (fail(
+            f"metal faces {idx_counts.get(METAL_IDX, 0)} < {METAL_FACES_MIN}", 5,
+        ),) + _no()
     if idx_counts.get(STONE_IDX, 0) < STONE_FACES_MIN:
-        return fail(
-            f"stone faces {idx_counts.get(STONE_IDX, 0)} < {STONE_FACES_MIN}",
-            5,
-        ), None, None, None, None, None
+        return (fail(
+            f"stone faces {idx_counts.get(STONE_IDX, 0)} < {STONE_FACES_MIN}", 5,
+        ),) + _no()
     if idx_counts.get(WOOD_IDX, 0) < WOOD_FACES_MIN:
-        return fail(
-            f"wood faces {idx_counts.get(WOOD_IDX, 0)} < {WOOD_FACES_MIN}",
-            5,
-        ), None, None, None, None, None
+        return (fail(
+            f"wood faces {idx_counts.get(WOOD_IDX, 0)} < {WOOD_FACES_MIN}", 5,
+        ),) + _no()
     if u0 < -UV_EPS or v0 < -UV_EPS or u1 > 1.0 + UV_EPS or v1 > 1.0 + UV_EPS:
-        return fail(
-            f"UVs outside 0..1: ({u0:.4f},{v0:.4f})-({u1:.4f},{v1:.4f})",
-            6,
-        ), None, None, None, None, None
+        return (fail(
+            f"UVs outside 0..1: ({u0:.4f},{v0:.4f})-({u1:.4f},{v1:.4f})", 6,
+        ),) + _no()
     if overlap > UV_OVERLAP_MAX:
-        return fail(
-            f"UV AABB overlap {overlap:.6f} > {UV_OVERLAP_MAX}",
-            7,
-        ), None, None, None, None, None
+        return (fail(f"UV AABB overlap {overlap:.6f} > {UV_OVERLAP_MAX}", 7),) + _no()
     if (
         abs(size_x - OUTER_SIZE[0]) > BBOX_TOL
         or abs(size_y - OUTER_SIZE[1]) > BBOX_TOL
         or abs(size_z - OUTER_SIZE[2]) > BBOX_TOL
     ):
-        return fail(
-            f"bbox ({size_x:.4f},{size_y:.4f},{size_z:.4f}) "
-            f"off outer {OUTER_SIZE}",
-            8,
-        ), None, None, None, None, None
+        return (fail(
+            f"bbox ({size_x:.4f},{size_y:.4f},{size_z:.4f}) off outer {OUTER_SIZE}", 8,
+        ),) + _no()
     if not (LOD1_RATIO_MIN <= r1 <= LOD1_RATIO_MAX):
-        return fail(
+        return (fail(
             f"LOD1 ratio {r1:.4f} not in [{LOD1_RATIO_MIN}, {LOD1_RATIO_MAX}] "
             "(--skip-decimate is the designed fail)",
             9,
-        ), None, None, None, None, None
+        ),) + _no()
     if not (LOD2_RATIO_MIN <= r2 <= LOD2_RATIO_MAX):
-        return fail(
-            f"LOD2 ratio {r2:.4f} not in [{LOD2_RATIO_MIN}, {LOD2_RATIO_MAX}]",
-            9,
-        ), None, None, None, None, None
+        return (fail(
+            f"LOD2 ratio {r2:.4f} not in [{LOD2_RATIO_MIN}, {LOD2_RATIO_MAX}]", 9,
+        ),) + _no()
     if col_tris > COLLIDER_TRIS_MAX:
-        return fail(
-            f"collider tris {col_tris} > {COLLIDER_TRIS_MAX}",
-            11,
-        ), None, None, None, None, None
+        return (fail(f"collider tris {col_tris} > {COLLIDER_TRIS_MAX}", 11),) + _no()
     if bake_result != {"FINISHED"} or not img.has_data:
-        return fail(
-            f"bake failed result={bake_result} has_data={img.has_data}",
-            12,
-        ), None, None, None, None, None
+        return (fail(
+            f"bake failed result={bake_result} has_data={img.has_data}", 12,
+        ),) + _no()
     if export_size <= 0:
-        return fail("export file missing or empty", 13), None, None, None, None, None
+        return (fail("export file missing or empty", 13),) + _no()
     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(
+        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}",
+            f"doubles={hyg['doubles']} ngons={hyg['ngons']} zfight={zf} "
+            "(--stray-vert and --flush-shoes are the designed fails)",
             15,
-        ), None, None, None, None, None
+        ),) + _no()
     if abs(bb[2]) > ZMIN_EPS:
-        return fail(
+        return (fail(
             f"zmin {bb[2]:.6f} not within {ZMIN_EPS} of 0 "
             "(--lift-z is the designed fail)",
             16,
-        ), None, None, None, None, None
+        ),) + _no()
     if sup["shoes"] < 4 or sup["shoe_z"] > SHOE_Z_MAX:
-        return fail(
+        return (fail(
             f"shoe supports {sup['shoes']} shoe_z={sup['shoe_z']:.5f} "
             "(--short-legs is the designed fail)",
             16,
-        ), None, None, None, None, None
+        ),) + _no()
     if cj > CRANK_JOIN:
-        return fail(
+        return (fail(
             f"crank-axle gap {cj:.5f} > {CRANK_JOIN} "
             "(--float-crank is the designed fail)",
             17,
-        ), None, None, None, None, None
+        ),) + _no()
     if sw > SHOE_JOIN:
-        return fail(
+        return (fail(
             f"shoe-wood gap {sw:.5f} > {SHOE_JOIN} "
             "(--float-legs is the designed fail)",
             17,
-        ), None, None, None, None, None
+        ),) + _no()
     if ts > TROUGH_SILL_JOIN:
-        return fail(
+        return (fail(
             f"trough-sill gap {ts:.5f} > {TROUGH_SILL_JOIN} "
             "(--narrow-trough is the designed fail)",
             18,
-        ), None, None, None, None, None
+        ),) + _no()
     if not (DIP_MIN <= st["dip"] <= DIP_MAX):
-        return fail(
+        return (fail(
             f"stone dip {st['dip']:.5f} not in [{DIP_MIN}, {DIP_MAX}] "
             "(--no-dip is the designed fail)",
             18,
-        ), None, None, None, None, None
+        ),) + _no()
     if st["trough_z"] < TROUGH_FLOOR_Z_MIN:
-        return fail(
+        return (fail(
             f"trough floor zmin {st['trough_z']:.5f} < {TROUGH_FLOOR_Z_MIN} "
             "(tub must sit on the frame, not the dirt)",
             18,
-        ), None, None, None, None, None
+        ),) + _no()
+    if len(bites) != 2 or bite_lo < TROUGH_BITE_MIN or bite_hi > TROUGH_BITE_MAX:
+        return (fail(
+            f"trough bearing: {len(bites)} stretchers, bite "
+            f"[{bite_lo:.5f}, {bite_hi:.5f}] outside "
+            f"[{TROUGH_BITE_MIN}, {TROUGH_BITE_MAX}] "
+            "(--low-stretchers is the designed fail: the tub hovers over "
+            "its bearers)",
+            18,
+        ),) + _no()
     if abs(st["dia"] - STONE_DIA) > STONE_DIA_TOL:
-        return fail(
-            f"stone diameter {st['dia']:.4f} off {STONE_DIA}",
-            19,
-        ), None, None, None, None, None
+        return (fail(f"stone diameter {st['dia']:.4f} off {STONE_DIA}", 19),) + _no()
     if abs(st["thick"] - STONE_T) > STONE_T_TOL:
-        return fail(
-            f"stone thickness {st['thick']:.4f} off {STONE_T}",
-            19,
-        ), None, None, None, None, None
+        return (fail(f"stone thickness {st['thick']:.4f} off {STONE_T}", 19),) + _no()
+    if n_right_angles > RIGHT_ANGLE_MAX:
+        return (fail(
+            f"right-angle edges {right_angles} > {RIGHT_ANGLE_MAX} "
+            "(--sharp-handle is the designed fail: the crank handle left "
+            "unchamfered)",
+            20,
+        ),) + _no()
+    if texel < TEXEL_MIN:
+        return (fail(
+            f"bake texel density {texel:.2f} px per UV cell < {TEXEL_MIN} "
+            "(--low-bake is the designed fail)",
+            21,
+        ),) + _no()
     return 0, low, high, stone, tex, collider
 
 
 def wire_normal(mat, tex):
+    """Chain the baked normal map under the stone's bump, not over it."""
     nt = mat.node_tree
     bsdf = nt.nodes["Principled BSDF"]
     nrm = nt.nodes.new("ShaderNodeNormalMap")
     nrm.inputs["Strength"].default_value = 1.0
     nt.links.new(tex.outputs["Color"], nrm.inputs["Color"])
-    nt.links.new(nrm.outputs["Normal"], bsdf.inputs["Normal"])
+    bump = next((n for n in nt.nodes if n.bl_idname == "ShaderNodeBump"), None)
+    if bump is not None:
+        nt.links.new(nrm.outputs["Normal"], bump.inputs["Normal"])
+    else:
+        nt.links.new(nrm.outputs["Normal"], bsdf.inputs["Normal"])
 
 
-def render_still(low, wood, tex, path, engine):
+def render_still(low, hero_mat, tex, path, engine):
     scene = bpy.context.scene
-    wire_normal(wood, tex)
+    wire_normal(hero_mat, tex)
     for ob in list(scene.objects):
         if ob.type == "MESH" and ob != low:
             ob.hide_render = True
@@ -1282,7 +1649,7 @@ def render_still(low, wood, tex, path, engine):
     floor_me = bpy.data.meshes.new("Floor")
     bm = bmesh.new()
     try:
-        bmesh.ops.create_grid(bm, x_segments=1, y_segments=1, size=14.0)
+        bmesh.ops.create_grid(bm, x_segments=1, y_segments=1, size=60.0)
         bm.to_mesh(floor_me)
     finally:
         bm.free()
@@ -1377,6 +1744,10 @@ def main():
     p.add_argument("--short-legs", action="store_true")
     p.add_argument("--float-legs", action="store_true")
     p.add_argument("--narrow-trough", action="store_true")
+    p.add_argument("--flush-shoes", action="store_true")
+    p.add_argument("--low-stretchers", action="store_true")
+    p.add_argument("--sharp-handle", action="store_true")
+    p.add_argument("--low-bake", action="store_true")
     args = p.parse_args(argv)
 
     code, low, _high, hero_mat, tex, _col = check(
@@ -1388,6 +1759,10 @@ def main():
         short_legs=args.short_legs,
         float_legs=args.float_legs,
         narrow_trough=args.narrow_trough,
+        flush_shoes=args.flush_shoes,
+        low_stretchers=args.low_stretchers,
+        sharp_handle=args.sharp_handle,
+        low_bake=args.low_bake,
     )
     if code:
         return code
diff --git a/showcase/grindstone/preview.webp b/showcase/grindstone/preview.webp
index 789cbc88..00ac59a3 100644
Binary files a/showcase/grindstone/preview.webp and b/showcase/grindstone/preview.webp differ