diff --git a/README.md b/README.md
index 561d9886..bb1f577b 100644
--- a/README.md
+++ b/README.md
@@ -117,10 +117,10 @@ Budget-conformance props. Not examples. Conventions: [`showcase/README.md`](show
   <a href="showcase/street-lantern/"><img src="showcase/street-lantern/preview.webp" width="24%" alt="Street lantern: an iron post with aged brass collars, a knee brace tenoned into post and arm, and a muntined amber cage on a dark studio floor" /></a>
   <a href="showcase/treasure-chest/"><img src="showcase/treasure-chest/preview.webp" width="24%" alt="Treasure chest: a slatted wooden chest with iron bands, corner brackets, and an open lid on a dark studio floor" /></a>
   <a href="showcase/terrain-scatter/"><img src="showcase/terrain-scatter/preview.webp" width="24%" alt="Terrain scatter: a Geometry Nodes dirt hill tile with bevelled masonry rocks on a dark studio floor" /></a>
-  <a href="showcase/fence-kit/"><img src="showcase/fence-kit/preview.webp" width="24%" alt="Fence kit: a timber post-and-rail section with pyramidal caps, iron shoes and straps on a dark studio floor" /></a>
+  <a href="showcase/fence-kit/"><img src="showcase/fence-kit/preview.webp" width="24%" alt="Fence kit: a grained timber post-and-rail section with pyramidal caps, a diagonal board brace, and iron shoes and bands on a dark studio floor" /></a>
   <a href="showcase/watchtower/"><img src="showcase/watchtower/preview.webp" width="24%" alt="Watchtower: a grained timber lookout with X-braces, hatch ladder, a plank platform on deck girts, and a coursed shake roof on a dark studio floor" /></a>
   <a href="showcase/cart/"><img src="showcase/cart/preview.webp" width="24%" alt="Cart: a two-wheel wooden cart with spoked wheels, slatted bed, and shafts on a dark studio floor" /></a>
-  <a href="showcase/park-bench/"><img src="showcase/park-bench/preview.webp" width="24%" alt="Park bench: a wrought-iron bench with scrolled legs and wooden slats on a dark studio floor" /></a>
+  <a href="showcase/park-bench/"><img src="showcase/park-bench/preview.webp" width="24%" alt="Park bench: a wrought-iron bench whose round-bar legs curl into scrolled feet, with wooden slats and a reclined back, on a dark studio floor" /></a>
   <a href="showcase/wheelbarrow/"><img src="showcase/wheelbarrow/preview.webp" width="24%" alt="Wheelbarrow: a wooden tray with walls of stacked boards and iron straps, a spoked wheel, rear legs, and handles on a dark studio floor" /></a>
   <a href="showcase/anvil/"><img src="showcase/anvil/preview.webp" width="24%" alt="Anvil: a dark forged-steel London-pattern anvil with a flared, squared waist on a hooped timber stump on a dark studio floor" /></a>
   <a href="showcase/water-trough/"><img src="showcase/water-trough/preview.webp" width="24%" alt="Water trough: a watertight wooden trough with plank ends, contained water, and trestle legs on a dark studio floor" /></a>
@@ -1008,7 +1008,7 @@ teleported flange) vs MPI KEEP.
 </tr>
 <tr>
 <td width="46%" valign="middle">
-<a href="examples/soccer-ball-goldberg/"><img src="examples/soccer-ball-goldberg/preview.webp" alt="Soccer ball Goldberg: a white soccer ball with black pentagon panels on a dark studio floor — a bmesh icosphere truncated at one-third per edge into the Goldberg polyhedron, proving closed-form counts, uniform degree, equal edges, planar faces, one circumsphere, and panels bound by face vertex count" /></a>
+<a href="examples/soccer-ball-goldberg/"><img src="examples/soccer-ball-goldberg/preview.webp" alt="Soccer ball Goldberg: a round white soccer ball with black pentagon panels and dark stitched seams around every hexagon on a dark studio floor — a bmesh icosphere truncated at one-third per edge into the Goldberg polyhedron, proving closed-form counts, uniform degree, equal edges, planar faces, one circumsphere, and panels bound by face vertex count" /></a>
 </td>
 <td valign="middle">
 
diff --git a/docs/gallery/assets/fence-kit-hero.webp b/docs/gallery/assets/fence-kit-hero.webp
index ad6fd732..8934e679 100644
Binary files a/docs/gallery/assets/fence-kit-hero.webp and b/docs/gallery/assets/fence-kit-hero.webp differ
diff --git a/docs/gallery/assets/park-bench-hero.webp b/docs/gallery/assets/park-bench-hero.webp
index a443e1ea..bd385496 100644
Binary files a/docs/gallery/assets/park-bench-hero.webp and b/docs/gallery/assets/park-bench-hero.webp differ
diff --git a/docs/gallery/assets/soccer-ball-goldberg-hero.webp b/docs/gallery/assets/soccer-ball-goldberg-hero.webp
index 1fb64452..145df865 100644
Binary files a/docs/gallery/assets/soccer-ball-goldberg-hero.webp and b/docs/gallery/assets/soccer-ball-goldberg-hero.webp differ
diff --git a/docs/gallery/contact-sheets/fence-kit-contact-sheet.webp b/docs/gallery/contact-sheets/fence-kit-contact-sheet.webp
index 346afba7..0e2e48be 100644
Binary files a/docs/gallery/contact-sheets/fence-kit-contact-sheet.webp and b/docs/gallery/contact-sheets/fence-kit-contact-sheet.webp differ
diff --git a/docs/gallery/contact-sheets/park-bench-contact-sheet.webp b/docs/gallery/contact-sheets/park-bench-contact-sheet.webp
index c71c1830..04304002 100644
Binary files a/docs/gallery/contact-sheets/park-bench-contact-sheet.webp and b/docs/gallery/contact-sheets/park-bench-contact-sheet.webp differ
diff --git a/docs/gallery/contact-sheets/soccer-ball-goldberg-contact-sheet.webp b/docs/gallery/contact-sheets/soccer-ball-goldberg-contact-sheet.webp
index 0ea8cf94..c24735db 100644
Binary files a/docs/gallery/contact-sheets/soccer-ball-goldberg-contact-sheet.webp and b/docs/gallery/contact-sheets/soccer-ball-goldberg-contact-sheet.webp differ
diff --git a/docs/gallery/fence-kit/index.html b/docs/gallery/fence-kit/index.html
index 2db63540..f64be0cc 100644
--- a/docs/gallery/fence-kit/index.html
+++ b/docs/gallery/fence-kit/index.html
@@ -4,25 +4,25 @@
   <meta charset="utf-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1" />
   <title>fence-kit — Showcase — Blender Developer Tools</title>
-  <meta name="description" content="A procedural post-and-rail fence section whose brace is an oriented box between named post stations, through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
+  <meta name="description" content="A procedural post-and-rail fence section that fits its 1.60 m tile, with one-shell iron bands and a board brace housed in both posts, 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/fence-kit/" />
   <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="fence-kit — Showcase — Blender Developer Tools" />
-  <meta property="og:description" content="A procedural post-and-rail fence section whose brace is an oriented box between named post stations, through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
+  <meta property="og:description" content="A procedural post-and-rail fence section that fits its 1.60 m tile, with one-shell iron bands and a board brace housed in both posts, 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/fence-kit/" />
   <meta property="og:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/fence-kit-hero.webp" />
   <meta property="og:image:width" content="1280" />
   <meta property="og:image:height" content="720" />
-  <meta property="og:image:alt" content="A section of wooden post-and-rail fence with a diagonal brace and dark iron collars." />
+  <meta property="og:image:alt" content="A section of grained timber post-and-rail fence with a diagonal board brace across the rails and dark iron bands and shoes on both posts." />
   <meta property="og:site_name" content="Blender Developer Tools" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="fence-kit — Showcase — Blender Developer Tools" />
-  <meta name="twitter:description" content="A procedural post-and-rail fence section whose brace is an oriented box between named post stations, through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
+  <meta name="twitter:description" content="A procedural post-and-rail fence section that fits its 1.60 m tile, with one-shell iron bands and a board brace housed in both posts, 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/fence-kit-hero.webp" />
-  <meta name="twitter:image:alt" content="A section of wooden post-and-rail fence with a diagonal brace and dark iron collars." />
+  <meta name="twitter:image:alt" content="A section of grained timber post-and-rail fence with a diagonal board brace across the rails and dark iron bands and shoes on both posts." />
   <style>
     /* fonts are deployed by the landing build (docs/fonts/) */
     @font-face { font-family: 'Barlow Condensed'; font-weight: 600; font-display: swap;
@@ -265,38 +265,39 @@
   </div>
   <header class="hero">
     <h1>fence-kit</h1>
-    <p>A procedural post-and-rail fence section whose brace is an oriented box between named post stations, through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.</p>
+    <p>A procedural post-and-rail fence section that fits its 1.60 m tile, with one-shell iron bands and a board brace housed in both posts, 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 section of wooden post-and-rail fence with a diagonal brace and dark iron collars.">
-      <img src="../assets/fence-kit-hero.webp" alt="A section of wooden post-and-rail fence with a diagonal brace and dark iron collars." width="1280" height="720" />
+    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: A section of grained timber post-and-rail fence with a diagonal board brace across the rails and dark iron bands and shoes on both posts.">
+      <img src="../assets/fence-kit-hero.webp" alt="A section of grained timber post-and-rail fence with a diagonal board brace across the rails and dark iron bands and shoes on both posts." 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: 1092 tris, two materials with 156 metal and 390 wood faces, UVs in 0..1 with zero AABB overlap, outer AABB 1.624×0.134×1.232 m, grounded zmin, 2 iron shoes, brace-to-post gap 2.4 mm on both posts, rail-to-post gap 0.93 mm, rail span 1.390 m, LOD ratios in band (5.2 COLLAPSE leaner on LOD2), convex collider 32 tris, hygiene all zero, non-empty glTF. --skip-decimate exits 9; --stray-vert 15; --lift-z/--short-shoes 16; --short-brace 17; --gap-rails 18; --long-rails 19.</div>
+    <div class="callout"><span class="tag">witnesses</span> Recomputed: 1012 tris, two materials with 116 metal and 390 wood faces, UVs in 0..1 with zero AABB overlap, outer AABB 1.596×0.134×1.232 m inside the 1.60 m tile, grounded zmin, 2 iron shoes, brace housed 12 mm in both posts and bearing 2 mm on the middle rail, rail-to-post gap 0.93 mm, rail span 1.362 m, LOD ratios in band (5.2 COLLAPSE leaner on LOD2), convex collider 24 tris, hygiene all zero, non-empty glTF. --skip-decimate exits 9; --stray-vert 15; --lift-z/--short-shoes 16; --short-brace 17; --gap-rails 18; --long-rails 19; --float-brace 20; --wide-tile 21.</div>
     <div class="runline">
       <pre id="runCmd">blender --background --python showcase/fence-kit/fence_kit.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 post-and-rail fence section (two posts, pyramidal caps, three rails, kickboard, a brace from named post stations, iron shoes and U-wrap straps) then the shipped pipeline: unique-cell UVs, Cycles high-to-low normal bake, LOD chain, convex collider, Unity glTF export.</p>
-<p>Posts, rails, kick, brace and collars share named stations (<code>POST_XS</code>, <code>RAIL_ZS</code>, <code>Y_BRACE</code>, <code>SHOE_H</code>). The brace is an oriented box from the left-post lower-rail station to the right-post upper-rail station on the back face, not a hypot-length box rotated about its centroid. Rails and kick tenon into the post volume; rail collars are U-wraps so the span-facing plate is not coplanar with the rail end.</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. AABB X is the tile width so adjacent copies meet; this piece does not re-witness the <code>modular-kit-snap</code> snap contract.</p>
+<p>A showcase piece, not an example. A procedural post-and-rail fence section (two posts, pyramidal caps, three rails, a kickboard, a board brace, iron shoes and U-bands), then 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>Posts, rails, kick, brace and bands share named stations (<code>POST_XS</code>, <code>RAIL_ZS</code>, <code>SHOE_H</code>). The post stations come from the tile. The outer faces of the iron bands sit <code>KIT_CLEAR</code> (2 mm) inside the tile edge, so copies placed at the 1.60 m pitch meet band to band without interpenetrating or sharing a plane. Each band is one shell, mitred at the corners. A rail band is a U open toward the span, with its arms stopped inside the post&#x27;s inner face. The brace is a board with plumb-cut ends, face-nailed to the middle rail and housed 12 mm into both posts. It clears the bottom rail at the left post and the top rail at the right one. Rails and kick tenon into the post volume.</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. This piece does not re-witness the <code>modular-kit-snap</code> snap contract.</p>
 <p><strong>Composes</strong> skills <code>mesh-editing-and-bmesh</code>, <code>bake-high-to-low</code>, <code>depsgraph-and-evaluated-data</code>, <code>engine-export-presets</code>, and snippets <code>bake_normal_high_to_low.py</code>, <code>setup_bake_target_image.py</code>, <code>lod_chain.py</code> / <code>decimate_to_budget.py</code>, <code>convex_hull_collider.py</code>, <code>export_preset_unity.py</code> (helpers copied, not imported as a package). Hygiene combinatorics match <code>examples/mesh-hygiene-audit</code> (copied, not imported).</p>
-<p>Intended size: 1.60 m bay, 1.14 m posts, 0.11 m post stock; outer AABB 1.624 × 0.134 × 1.232 m.</p>
+<p>Intended size: 1.60 m tile, 1.14 m posts, 0.11 m post stock. Outer AABB 1.596 × 0.134 × 1.232 m.</p>
 <h2>Budgets</h2>
-<p>Declared as named constants; every gate <strong>recomputes</strong> from the mesh, materials, UVs, evaluated LOD, collider, or export file.</p>
-<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>1000–1400</td><td>1092 / 1092 / 1092</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.1832</td></tr><tr><td>Materials</td><td>exactly 2 distinct, ≥48 metal, ≥24 wood</td><td>2 slots, 156 metal / 390 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.624, 0.134, 1.232) m ± 0.015</td><td>(1.6240, 0.1340, 1.2320), zmin 0</td></tr><tr><td>Collider tris</td><td>≤ 180</td><td>32</td></tr><tr><td>Export</td><td>written, size &gt; 0</td><td>82216 / 82216 / 82208 bytes</td></tr></tbody></table></div>
-<p>Base triangles dropped from <strong>1212 to 1092</strong> in the quality pass: rail collars became U-wraps (no span-facing plate). Outer AABB tightened from 1.642 × 0.157 × 1.235 m.</p>
-<p>DECIMATE COLLAPSE triangle counts are <strong>not</strong> identical across series — 5.2.1 is more aggressive on LOD2. The gate is a ratio band, not an exact count. Bake pixels are stochastic; the gate is <code>has_data</code> plus operator <code>FINISHED</code>, not byte-identity. Construction uses no RNG. Export byte counts differ by 8 B on 5.2.1 (glTF serializer), not a gated axis.</p>
+<p>Declared as named constants. Every gate <strong>recomputes</strong> its value 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>850–1200</td><td>1012 / 1012 / 1012</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.2174</td></tr><tr><td>Materials</td><td>exactly 2 distinct, ≥48 metal, ≥48 wood</td><td>2 slots, 116 metal / 390 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.596, 0.134, 1.232) m ± 0.015</td><td>(1.5960, 0.1340, 1.2320), zmin 0</td></tr><tr><td>Collider tris</td><td>≤ 180</td><td>24</td></tr><tr><td>Export</td><td>written, size &gt; 0</td><td>75900 / 75900 / 75888 bytes</td></tr></tbody></table></div>
+<p>Base triangles dropped from <strong>1092 to 1012</strong> in the second quality pass. Each band became one mitred shell instead of three or four separate plates, and the brace became a six-face board. The band was re-fitted around the measurement and narrowed from 1000–1400.</p>
+<p>DECIMATE COLLAPSE triangle counts are <strong>not</strong> identical across series: 5.2.1 is more aggressive on LOD2. The gate is a ratio band, not an exact count. Bake pixels are stochastic; the gate is <code>has_data</code> plus operator <code>FINISHED</code>, not byte-identity. Construction is closed-form and plank tones are seeded, so repeated runs on one binary print identical measurements. Export byte counts differ by 12 B on 5.2.1 (glTF serializer), not a gated axis.</p>
 <h3>Hygiene</h3>
 <p>Recomputed from the generated mesh, not asserted about the script.</p>
 <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 shoes</td><td>2, each <code>zmin</code> ≤ 0.002</td><td>2, 0.00000</td></tr></tbody></table></div>
-<h3>Joint fit and span</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>Brace-to-post BVH gap (both posts)</td><td>≤ 0.008 m</td><td>0.00240</td></tr><tr><td>Rail-to-post BVH gap</td><td>≤ 0.008 m</td><td>0.00093</td></tr><tr><td>Rail span vs <code>2·RAIL_HALF</code></td><td>± 0.04 m</td><td>1.3900 vs 1.390</td></tr></tbody></table></div>
+<h3>Joint fit, bearing and tiling</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>Brace-to-post BVH gap (both posts)</td><td>≤ 0.008 m</td><td>0.00531</td></tr><tr><td>Rail-to-post BVH gap</td><td>≤ 0.008 m</td><td>0.00093</td></tr><tr><td>Rail span vs <code>2·RAIL_HALF</code></td><td>± 0.04 m</td><td>1.3620 vs 1.362</td></tr><tr><td>Brace housing (exit 20): deepest brace vertex inside each post</td><td>≥ 0.004 m</td><td>0.01200</td></tr><tr><td>Brace bearing (exit 20): brace back plane past the middle rail&#x27;s front plane, where their heights overlap</td><td>≥ 0.001 m</td><td>0.00200</td></tr><tr><td>Tile fit (exit 21): section width along the tiling axis</td><td>1.590–1.600 m</td><td>1.5960</td></tr></tbody></table></div>
+<p>The brace bearing is measured plane to plane. The brace and the middle rail cross mid-span, and neither has a vertex there, so a vertex-depth metric reports a false gap of 0.15 m.</p>
 <h3>Falsifiers</h3>
 <p>Each violates one named budget. All were run on 4.5.11, 5.1.2 and 5.2.1 and returned the same code on each.</p>
-<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-shoes</code></td><td>named shoes plant at z=0</td><td>16</td></tr><tr><td><code>--short-brace</code></td><td>brace-to-post BVH gap (both posts)</td><td>17</td></tr><tr><td><code>--gap-rails</code></td><td>rail-to-post BVH gap</td><td>18</td></tr><tr><td><code>--long-rails</code></td><td>rail span vs <code>2·RAIL_HALF</code></td><td>19</td></tr></tbody></table></div>
-<p><code>--short-shoes</code> lifts only the iron shoes. After recenter a post or kick is the AABB <code>zmin</code>, so the AABB gate would still pass; the named-shoe stations fail. <code>--short-brace</code> shortens the left station; <code>brace_gap</code> is the max of the per-post minima so a brace that still hits the right post cannot sneak through. <code>--long-rails</code> adds an extra spanning board; the tenoned rails stay put so the gap budget still passes.</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-shoes</code></td><td>named shoes plant at z=0</td><td>16</td></tr><tr><td><code>--short-brace</code></td><td>brace-to-post BVH gap (both posts)</td><td>17</td></tr><tr><td><code>--gap-rails</code></td><td>rail-to-post BVH gap</td><td>18</td></tr><tr><td><code>--long-rails</code></td><td>rail span vs <code>2·RAIL_HALF</code></td><td>19</td></tr><tr><td><code>--float-brace</code></td><td>brace bearing on the middle rail (brace 6 mm forward; measured −0.00400)</td><td>20</td></tr><tr><td><code>--wide-tile</code></td><td>tile fit (the first build&#x27;s post stations; measured 1.6240)</td><td>21</td></tr></tbody></table></div>
+<p><code>--short-shoes</code> lifts only the iron shoes. After recentring, a post or the kick is the AABB <code>zmin</code>, so the AABB gate would still pass. The named-shoe stations fail. <code>--short-brace</code> shortens the left end; <code>brace_gap</code> is the maximum of the per-post minima, so a brace that still reaches the right post cannot sneak through. <code>--long-rails</code> adds an extra spanning board, and the tenoned rails stay put, so the gap budget still passes. <code>--wide-tile</code> moves the posts out to where the first build had them and moves the rails with them. It is checked before the AABB gate, which it would also fail.</p>
 <h2>Run</h2>
 <pre><code>blender --background --python fence_kit.py --
 blender --background --python fence_kit.py -- --skip-decimate
@@ -306,11 +307,13 @@ <h2>Run</h2>
 blender --background --python fence_kit.py -- --short-brace
 blender --background --python fence_kit.py -- --gap-rails
 blender --background --python fence_kit.py -- --long-rails
+blender --background --python fence_kit.py -- --float-brace
+blender --background --python fence_kit.py -- --wide-tile
 blender --background --python fence_kit.py -- --output fence.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 ≠ 2 distinct slots, or wood/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 (<code>--stray-vert</code> lands here)</td></tr><tr><td>16</td><td>Grounded zmin / named shoes (<code>--lift-z</code>, <code>--short-shoes</code>)</td></tr><tr><td>17</td><td>Brace-to-post gap (<code>--short-brace</code>)</td></tr><tr><td>18</td><td>Rail-to-post gap (<code>--gap-rails</code>)</td></tr><tr><td>19</td><td>Rail span (<code>--long-rails</code>)</td></tr></tbody></table></div>
+<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. <code>20</code> and <code>21</code> are this piece&#x27;s own.</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 wood/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 (<code>--stray-vert</code> lands here)</td></tr><tr><td>16</td><td>Grounded zmin / named shoes (<code>--lift-z</code>, <code>--short-shoes</code>)</td></tr><tr><td>17</td><td>Brace-to-post gap (<code>--short-brace</code>)</td></tr><tr><td>18</td><td>Rail-to-post gap (<code>--gap-rails</code>)</td></tr><tr><td>19</td><td>Rail span (<code>--long-rails</code>)</td></tr><tr><td>20</td><td>Brace not housed in both posts or not bearing on the middle rail (<code>--float-brace</code>)</td></tr><tr><td>21</td><td>Section does not fit its tile (<code>--wide-tile</code>)</td></tr></tbody></table></div>
     </section>
     <section class="detail-section src">
       <h2>Source</h2>
@@ -325,23 +328,25 @@ <h2>Source</h2>
 materials, high-to-low normal bake, LOD chain, convex collider,
 Unity glTF export.
 
-Posts, rails, kick, brace and collars share named stations
-(``post_xs``, ``RAIL_ZS``, ``y_brace``). The brace is an oriented
-box between those stations, not a hypot-length cube rotated about
-its centroid. Rails and kick tenon into the post volume without
-sharing corner verts.
+Posts, rails, kick, brace and iron bands share named stations
+(``POST_XS``, ``RAIL_ZS``, ``SHOE_H``). The post stations come from the
+tile: the outer face of the iron bands sits ``KIT_CLEAR`` inside the tile
+edge, so adjacent copies meet without interpenetrating. Each band is one
+mitred shell. The brace is a board with plumb-cut ends, face-nailed to
+the middle rail and housed in both posts. Rails and kick tenon into the
+post volume without sharing corner verts.
 
 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. Hygiene family 15–19:
 ``--stray-vert``, ``--lift-z`` / ``--short-shoes``, ``--short-brace``,
-``--gap-rails``, ``--long-rails``.
+``--gap-rails``, ``--long-rails``. ``--float-brace`` fails the brace
+bearing (20); ``--wide-tile`` fails the tile fit (21).
 
-No RNG. Construction is closed-form. AABB X is the tile width so
-adjacent copies meet; this piece does not re-witness the modular-kit
-snap contract. DECIMATE COLLAPSE triangle counts are not byte-identical
-across Blender versions — the LOD gate is a ratio band, not an exact
-count.
+Construction is closed-form; plank tones use a seeded RNG. This piece
+does not re-witness the modular-kit snap contract. 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 fence_kit.py --
     blender --background --python fence_kit.py -- --skip-decimate
@@ -350,6 +355,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
@@ -380,16 +386,32 @@ <h2>Source</h2>
 IRON_T = <span class="n">0.016</span>
 SHOE_H = <span class="n">0.034</span>
 TENON = <span class="n">0.005</span>
-POST_XS = (-(TILE / <span class="n">2.0</span> - POST_W / <span class="n">2.0</span>), TILE / <span class="n">2.0</span> - POST_W / <span class="n">2.0</span>)
-HX = POST_XS[<span class="n">1</span>]
-Y_BRACE = -(POST_W * <span class="n">0.5</span> - BRACE_T * <span class="n">0.30</span>)
-RAIL_HALF = HX - POST_W * <span class="n">0.5</span> + TENON
 COLLAR_BITE = <span class="n">0.004</span>
+<span class="c"># The section tiles at TILE: the outer face of the iron bands, not the post</span>
+<span class="c"># centre, sits a named clearance inside the tile edge, so neighbouring</span>
+<span class="c"># copies meet band to band without interpenetrating or sharing a plane.</span>
+KIT_CLEAR = <span class="n">0.002</span>
+TILE_FIT_TOL = <span class="n">0.010</span>
+WIDE_TILE_CLEAR = -<span class="n">0.012</span>
+BAND_REACH = POST_W / <span class="n">2.0</span> - COLLAR_BITE + IRON_T
+HX = TILE / <span class="n">2.0</span> - KIT_CLEAR - BAND_REACH
+POST_XS = (-HX, HX)
+RAIL_HALF = HX - POST_W * <span class="n">0.5</span> + TENON
+BRACE_D = <span class="n">0.022</span>
+BRACE_BITE = <span class="n">0.002</span>
+BRACE_TENON = <span class="n">0.012</span>
+BRACE_CLEAR = <span class="n">0.012</span>
+FLOAT_BRACE = <span class="n">0.006</span>
+BRACE_POST_BITE_MIN = <span class="n">0.004</span>
+BRACE_RAIL_BITE_MIN = <span class="n">0.001</span>
+PLANK_TONE_JITTER = <span class="n">0.28</span>
+TONE_SEED = <span class="n">17</span>
+WOOD_GRAIN_SCALE = <span class="n">30.0</span>
 
 BBOX_TOL = <span class="n">0.015</span>
-OUTER_SIZE = (<span class="n">1.624</span>, <span class="n">0.134</span>, <span class="n">1.232</span>)
-BASE_TRIS_MIN = <span class="n">1000</span>
-BASE_TRIS_MAX = <span class="n">1400</span>
+OUTER_SIZE = (<span class="n">1.596</span>, <span class="n">0.134</span>, <span class="n">1.232</span>)
+BASE_TRIS_MIN = <span class="n">850</span>
+BASE_TRIS_MAX = <span class="n">1200</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>
@@ -490,25 +512,78 @@ <h2>Source</h2>
 
 
 <span class="k">def</span> add_collar(bm, px, z, half, t, h, mat_idx, closed=<span class="k">True</span>):
-    <span class="s">&quot;&quot;&quot;Plates around a post. Bite the host. U-wrap omits the span-facing plate.&quot;&quot;&quot;</span>
-    loc_y = half - COLLAR_BITE + t * <span class="n">0.5</span>
-    add_box(bm, (px, loc_y, z), (<span class="n">2.0</span> * half - t * <span class="n">0.50</span>, t, h), mat_idx)
-    add_box(bm, (px, -loc_y, z), (<span class="n">2.0</span> * half - t * <span class="n">0.50</span>, t, h), mat_idx)
-    loc_x = half - COLLAR_BITE + t * <span class="n">0.5</span>
-    sign = <span class="n">1.0</span> <span class="k">if</span> px &gt;= <span class="n">0.0</span> <span class="k">else</span> -<span class="n">1.0</span>
-    add_box(
-        bm,
-        (px + sign * loc_x, <span class="n">0.0</span>, z),
-        (t, <span class="n">2.0</span> * half - t * <span class="n">0.70</span>, h),
-        mat_idx,
-    )
+    <span class="s">&quot;&quot;&quot;One iron band around a post, mitred at the corners, one shell.
+
+    Inner face a named bite inside the post, outer face proud of it. A U
+    band (``closed=False``) leaves the span-facing side open for the rail
+    and stops its arms a quarter-thickness inside the post&#x27;s inner face,
+    so no arm end lands on that face&#x27;s plane. The first build was three or
+    four separate plates with open slits at every corner.
+    &quot;&quot;&quot;</span>
+    a = half - COLLAR_BITE
+    b = a + t
+    s = <span class="n">1.0</span> <span class="k">if</span> px &gt;= <span class="n">0.0</span> <span class="k">else</span> -<span class="n">1.0</span>
     <span class="k">if</span> closed:
-        add_box(
-            bm,
-            (px - sign * loc_x, <span class="n">0.0</span>, z),
-            (t, <span class="n">2.0</span> * half - t * <span class="n">0.70</span>, h),
-            mat_idx,
-        )
+        outer = [(b, b), (-b, b), (-b, -b), (b, -b)]
+        inner = [(a, a), (-a, a), (-a, -a), (a, -a)]
+    <span class="k">else</span>:
+        e = half - t * <span class="n">0.25</span>
+        outer = [(-e, -b), (b, -b), (b, b), (-e, b)]
+        inner = [(-e, -a), (a, -a), (a, a), (-e, a)]
+    z0, z1 = z - h * <span class="n">0.5</span>, z + h * <span class="n">0.5</span>
+
+    <span class="k">def</span> ring(pts, zz):
+        <span class="k">return</span> [bm.verts.new((px + s * x, y, zz)) <span class="k">for</span> x, y <span class="k">in</span> pts]
+
+    ob, ot = ring(outer, z0), ring(outer, z1)
+    ib, it = ring(inner, z0), ring(inner, z1)
+    n = len(outer)
+    segs = range(n) <span class="k">if</span> closed <span class="k">else</span> range(n - <span class="n">1</span>)
+    faces = []
+    <span class="k">for</span> i <span class="k">in</span> segs:
+        j = (i + <span class="n">1</span>) % n
+        faces.append(bm.faces.new((ob[i], ob[j], ot[j], ot[i])))
+        faces.append(bm.faces.new((ib[j], ib[i], it[i], it[j])))
+        faces.append(bm.faces.new((ot[i], ot[j], it[j], it[i])))
+        faces.append(bm.faces.new((ob[j], ob[i], ib[i], ib[j])))
+    <span class="k">if</span> <span class="k">not</span> closed:
+        <span class="k">for</span> i <span class="k">in</span> (<span class="n">0</span>, n - <span class="n">1</span>):
+            faces.append(bm.faces.new((ob[i], ib[i], it[i], ot[i])))
+    <span class="k">for</span> f <span class="k">in</span> faces:
+        f.material_index = mat_idx
+    <span class="k">return</span> ob + ot + ib + it
+
+
+<span class="k">def</span> add_brace(bm, x0, z0, x1, z1, y_back, depth, height, mat_idx):
+    <span class="s">&quot;&quot;&quot;A board brace between two posts, ends cut plumb.
+
+    A box rotated onto the diagonal has ends square to its own axis: one
+    corner buries itself in the post and the other stands off in the air.
+    Cut plumb, both ends enter the post faces along their full height.
+    &quot;&quot;&quot;</span>
+    y_front = y_back - depth
+    vs = []
+    <span class="k">for</span> x, zc <span class="k">in</span> ((x0, z0), (x1, z1)):
+        <span class="k">for</span> y <span class="k">in</span> (y_back, y_front):
+            <span class="k">for</span> dz <span class="k">in</span> (-<span class="n">0.5</span>, <span class="n">0.5</span>):
+                vs.append(bm.verts.new((x, y, zc + dz * height)))
+    <span class="c"># index: (end, y, z) -&gt; end*4 + y*2 + z</span>
+    q = [
+        (<span class="n">0</span>, <span class="n">1</span>, <span class="n">3</span>, <span class="n">2</span>), (<span class="n">4</span>, <span class="n">6</span>, <span class="n">7</span>, <span class="n">5</span>),       <span class="c"># plumb ends</span>
+        (<span class="n">0</span>, <span class="n">4</span>, <span class="n">5</span>, <span class="n">1</span>), (<span class="n">2</span>, <span class="n">3</span>, <span class="n">7</span>, <span class="n">6</span>),       <span class="c"># back / front faces</span>
+        (<span class="n">0</span>, <span class="n">2</span>, <span class="n">6</span>, <span class="n">4</span>), (<span class="n">1</span>, <span class="n">5</span>, <span class="n">7</span>, <span class="n">3</span>),       <span class="c"># underside / top</span>
+    ]
+    <span class="k">for</span> quad <span class="k">in</span> q:
+        bm.faces.new([vs[i] <span class="k">for</span> i <span class="k">in</span> quad]).material_index = mat_idx
+    <span class="k">return</span> vs
+
+
+<span class="k">def</span> rail_depth(i):
+    <span class="k">return</span> RAIL_Y * (<span class="n">1.0</span> + <span class="n">0.10</span> * math.sin(i * <span class="n">2.15</span> + <span class="n">0.3</span>))
+
+
+<span class="k">def</span> rail_height(i):
+    <span class="k">return</span> RAIL_Z * (<span class="n">1.0</span> + <span class="n">0.06</span> * math.sin(i * <span class="n">1.7</span> + <span class="n">1.1</span>))
 
 
 <span class="k">def</span> add_cone(bm, loc, radius1, radius2, depth, segments, mat_idx, euler=(<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>)):
@@ -583,13 +658,18 @@ <h2>Source</h2>
     short_shoes=<span class="k">False</span>,
     gap_rails=<span class="k">False</span>,
     long_rails=<span class="k">False</span>,
+    float_brace=<span class="k">False</span>,
+    wide_tile=<span class="k">False</span>,
 ):
     bm = bmesh.new()
     <span class="k">try</span>:
         wood_verts = []
-        post_xs = POST_XS
         half = POST_W * <span class="n">0.5</span>
-        rail_half = RAIL_HALF - GAP_RAIL <span class="k">if</span> gap_rails <span class="k">else</span> RAIL_HALF
+        hx = TILE / <span class="n">2.0</span> - (WIDE_TILE_CLEAR <span class="k">if</span> wide_tile <span class="k">else</span> KIT_CLEAR) - BAND_REACH
+        post_xs = (-hx, hx)
+        rail_half = hx - half + TENON
+        <span class="k">if</span> gap_rails:
+            rail_half -= GAP_RAIL
 
         <span class="k">for</span> px <span class="k">in</span> post_xs:
             wood_verts.extend(
@@ -602,8 +682,8 @@ <h2>Source</h2>
             )
 
         <span class="k">for</span> i, z <span class="k">in</span> enumerate(RAIL_ZS):
-            ry = RAIL_Y * (<span class="n">1.0</span> + <span class="n">0.10</span> * math.sin(i * <span class="n">2.15</span> + <span class="n">0.3</span>))
-            rz = RAIL_Z * (<span class="n">1.0</span> + <span class="n">0.06</span> * math.sin(i * <span class="n">1.7</span> + <span class="n">1.1</span>))
+            ry = rail_depth(i)
+            rz = rail_height(i)
             wood_verts.extend(
                 add_box(bm, (<span class="n">0.0</span>, <span class="n">0.0</span>, z), (<span class="n">2.0</span> * rail_half, ry, rz), WOOD_IDX)
             )
@@ -628,14 +708,35 @@ <h2>Source</h2>
                 )
             )
 
-        a = Vector((post_xs[<span class="n">0</span>], Y_BRACE, RAIL_ZS[<span class="n">0</span>]))
-        b = Vector((post_xs[<span class="n">1</span>], Y_BRACE, RAIL_ZS[-<span class="n">1</span>]))
-        <span class="k">if</span> short_brace:
-            a = Vector((post_xs[<span class="n">0</span>] + SHORT_BRACE, Y_BRACE, RAIL_ZS[<span class="n">0</span>]))
-        wood_verts.extend(add_oriented_box(bm, a, b, (BRACE_T, BRACE_T), WOOD_IDX))
+        <span class="c"># The brace is a board face-nailed to the middle rail and housed in</span>
+        <span class="c"># both posts: it clears the bottom rail at the left post and the top</span>
+        <span class="c"># rail at the right one, and its back face bites the middle rail.</span>
+        <span class="c"># The first build ran post centre to post centre through the rail</span>
+        <span class="c"># bands, 6 mm into all three rails, with square-cut ends.</span>
+        x_a = post_xs[<span class="n">0</span>] + half
+        x_b = post_xs[<span class="n">1</span>] - half
+        h = BRACE_T
+        <span class="k">for</span> _ <span class="k">in</span> range(<span class="n">3</span>):
+            z_a = RAIL_ZS[<span class="n">0</span>] + rail_height(<span class="n">0</span>) / <span class="n">2.0</span> + BRACE_CLEAR + h / <span class="n">2.0</span>
+            z_b = RAIL_ZS[-<span class="n">1</span>] - rail_height(len(RAIL_ZS) - <span class="n">1</span>) / <span class="n">2.0</span> - BRACE_CLEAR - h / <span class="n">2.0</span>
+            slope = (z_b - z_a) / (x_b - x_a)
+            h = BRACE_T * math.sqrt(<span class="n">1.0</span> + slope * slope)
+        x0 = x_a - BRACE_TENON + (SHORT_BRACE <span class="k">if</span> short_brace <span class="k">else</span> <span class="n">0.0</span>)
+        x1 = x_b + BRACE_TENON
+        y_back = -rail_depth(<span class="n">1</span>) / <span class="n">2.0</span> + BRACE_BITE - (FLOAT_BRACE <span class="k">if</span> float_brace <span class="k">else</span> <span class="n">0.0</span>)
+        wood_verts.extend(
+            add_brace(
+                bm,
+                x0, z_a + slope * (x0 - x_a),
+                x1, z_a + slope * (x1 - x_a),
+                y_back, BRACE_D, h, WOOD_IDX,
+            )
+        )
 
         <span class="k">if</span> bevel_offset &gt; <span class="n">0.0</span>:
-            edges = list({e <span class="k">for</span> v <span class="k">in</span> wood_verts <span class="k">for</span> e <span class="k">in</span> v.link_edges})
+            <span class="c"># A set of BMEdges iterates in memory order; sort by index.</span>
+            bm.edges.index_update()
+            edges = sorted({e <span class="k">for</span> v <span class="k">in</span> wood_verts <span class="k">for</span> e <span class="k">in</span> v.link_edges}, key=<span class="k">lambda</span> e: e.index)
             ret = bmesh.ops.bevel(
                 bm,
                 geom=edges,
@@ -714,9 +815,142 @@ <h2>Source</h2>
         fac = mix.inputs.get(<span class="s">&quot;Factor&quot;</span>) <span class="k">or</span> mix.inputs.get(<span class="s">&quot;Fac&quot;</span>)
         nt.links.new(tex.outputs[<span class="s">&quot;Fac&quot;</span>], fac)
         nt.links.new(mix.outputs[<span class="s">&quot;Result&quot;</span>], bsdf.inputs[<span class="s">&quot;Base Color&quot;</span>])
+        rmix = nt.nodes.new(<span class="s">&quot;ShaderNodeMix&quot;</span>)
+        rmix.data_type = <span class="s">&quot;FLOAT&quot;</span>
+        rmix.inputs[<span class="s">&quot;A&quot;</span>].default_value = roughness
+        rmix.inputs[<span class="s">&quot;B&quot;</span>].default_value = min(<span class="n">1.0</span>, roughness + <span class="n">0.18</span>)
+        rfac = rmix.inputs.get(<span class="s">&quot;Factor&quot;</span>) <span class="k">or</span> rmix.inputs.get(<span class="s">&quot;Fac&quot;</span>)
+        nt.links.new(tex.outputs[<span class="s">&quot;Fac&quot;</span>], rfac)
+        nt.links.new(rmix.outputs[<span class="s">&quot;Result&quot;</span>], bsdf.inputs[<span class="s">&quot;Roughness&quot;</span>])
     <span class="k">return</span> mat
 
 
+<span class="k">def</span> _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 post, rail, kick, brace and cap is its own shell, so each gets
+    one tone and grain along its own long axis. Iron shells get a tone
+    too; the iron shader ignores it.
+    &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> shells(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> _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``).&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> fence_materials():
+    <span class="s">&quot;&quot;&quot;(wood, metal): shared by the check, the render and inspection.
+
+    The first build was one flat brown on every member and satin iron
+    (metallic 1.0, roughness 0.28) that read as chrome.
+    &quot;&quot;&quot;</span>
+    wood = wood_material(<span class="s">&quot;FenceWood&quot;</span>)
+    metal = principled(
+        <span class="s">&quot;FenceIron&quot;</span>, (<span class="n">0.045</span>, <span class="n">0.046</span>, <span class="n">0.048</span>, <span class="n">1.0</span>), <span class="n">0.60</span>, <span class="n">0.55</span>,
+        noise_scale=<span class="n">18.0</span>, wear=(<span class="n">0.13</span>, <span class="n">0.062</span>, <span class="n">0.028</span>, <span class="n">1.0</span>),
+    )
+    <span class="k">return</span> wood, metal
+
+
 <span class="k">def</span> assign_slots(obj, wood, metal):
     <span class="c"># Do not materials.clear() — that resets polygon material_index to 0</span>
     <span class="c"># on this Blender, which would drop metal faces onto wood.</span>
@@ -933,6 +1167,32 @@ <h2>Source</h2>
         bm.free()
 
 
+<span class="k">def</span> shell_bite(me, ga, gb):
+    <span class="s">&quot;&quot;&quot;Deepest vertex of shell ``ga`` inside closed shell ``gb`` (m); negative if none is.&quot;&quot;&quot;</span>
+    bm_b = bmesh.new()
+    <span class="k">try</span>:
+        bm_b.from_mesh(me)
+        keep_b = set(gb)
+        drop_b = [f <span class="k">for</span> f <span class="k">in</span> bm_b.faces <span class="k">if</span> <span class="k">not</span> all(v.index <span class="k">in</span> keep_b <span class="k">for</span> v <span class="k">in</span> f.verts)]
+        <span class="k">if</span> drop_b:
+            bmesh.ops.delete(bm_b, geom=drop_b, context=<span class="s">&quot;FACES&quot;</span>)
+        <span class="k">if</span> <span class="k">not</span> bm_b.faces:
+            <span class="k">return</span> -<span class="n">1e9</span>
+        bmesh.ops.recalc_face_normals(bm_b, faces=list(bm_b.faces))
+        tree = BVHTree.FromBMesh(bm_b)
+        best = -<span class="n">1e9</span>
+        <span class="k">for</span> i <span class="k">in</span> ga:
+            co = me.vertices[i].co
+            loc, nrm, _idx, dist = tree.find_nearest(co)
+            <span class="k">if</span> loc <span class="k">is</span> <span class="k">None</span>:
+                <span class="k">continue</span>
+            depth = dist <span class="k">if</span> (co - loc).dot(nrm) &lt; <span class="n">0.0</span> <span class="k">else</span> -dist
+            best = max(best, depth)
+        <span class="k">return</span> best
+    <span class="k">finally</span>:
+        bm_b.free()
+
+
 <span class="k">def</span> joint_audit(me):
     groups = shells(me)
     posts = []
@@ -972,7 +1232,25 @@ <h2>Source</h2>
     <span class="k">if</span> rails:
         xs = [v <span class="k">for</span> _g, a <span class="k">in</span> rails <span class="k">for</span> v <span class="k">in</span> (a[<span class="n">0</span>], a[<span class="n">3</span>])]
         span_x = max(xs) - min(xs)
+    <span class="c"># The brace is housed in both posts (deepest brace vertex inside each</span>
+    <span class="c"># post) and bears on the middle rail. Neither has a vertex where they</span>
+    <span class="c"># cross mid-span, so the bearing is the brace&#x27;s back plane measured</span>
+    <span class="c"># against the rail&#x27;s front plane, both read off the mesh, and only</span>
+    <span class="c"># counted where their heights overlap.</span>
+    post_bites = [shell_bite(me, b[<span class="n">0</span>], p[<span class="n">0</span>]) <span class="k">for</span> b <span class="k">in</span> braces <span class="k">for</span> p <span class="k">in</span> posts]
+    brace_post_bite = min(post_bites) <span class="k">if</span> post_bites <span class="k">else</span> -<span class="n">1.0</span>
+    brace_rail_bite = -<span class="n">1.0</span>
+    <span class="k">if</span> braces <span class="k">and</span> rails:
+        <span class="c"># The middle rail is the one centred on its station, whatever its</span>
+        <span class="c"># length, so a falsifier that moves the posts still finds it.</span>
+        mid = min(rails, key=<span class="k">lambda</span> r: abs(<span class="n">0.5</span> * (r[<span class="n">1</span>][<span class="n">2</span>] + r[<span class="n">1</span>][<span class="n">5</span>]) - RAIL_ZS[<span class="n">1</span>]))[<span class="n">1</span>]
+        brace_rail_bite = min(
+            (b[<span class="n">1</span>][<span class="n">4</span>] - mid[<span class="n">1</span>]) <span class="k">if</span> (b[<span class="n">1</span>][<span class="n">2</span>] &lt; mid[<span class="n">5</span>] <span class="k">and</span> b[<span class="n">1</span>][<span class="n">5</span>] &gt; mid[<span class="n">2</span>]) <span class="k">else</span> -<span class="n">1.0</span>
+            <span class="k">for</span> b <span class="k">in</span> braces
+        )
     <span class="k">return</span> {
+        <span class="s">&quot;brace_post_bite&quot;</span>: brace_post_bite,
+        <span class="s">&quot;brace_rail_bite&quot;</span>: brace_rail_bite,
         <span class="s">&quot;posts&quot;</span>: len(posts),
         <span class="s">&quot;rails&quot;</span>: len(rails),
         <span class="s">&quot;braces&quot;</span>: len(braces),
@@ -1044,6 +1322,8 @@ <h2>Source</h2>
     short_shoes=<span class="k">False</span>,
     gap_rails=<span class="k">False</span>,
     long_rails=<span class="k">False</span>,
+    float_brace=<span class="k">False</span>,
+    wide_tile=<span class="k">False</span>,
 ):
     bpy.ops.wm.read_factory_settings(use_empty=<span class="k">True</span>)
     kw = dict(
@@ -1051,17 +1331,14 @@ <h2>Source</h2>
         short_shoes=short_shoes,
         gap_rails=gap_rails,
         long_rails=long_rails,
+        float_brace=float_brace,
+        wide_tile=wide_tile,
     )
     low = build_fence_mesh(<span class="s">&quot;FenceLow&quot;</span>, bevel_offset=<span class="n">0.006</span>, bevel_segments=<span class="n">2</span>, **kw)
     high = build_fence_mesh(<span class="s">&quot;FenceHigh&quot;</span>, bevel_offset=<span class="n">0.006</span>, bevel_segments=<span class="n">4</span>, **kw)
-    wood = principled(
-        <span class="s">&quot;FenceWood&quot;</span>, (<span class="n">0.46</span>, <span class="n">0.24</span>, <span class="n">0.08</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.55</span>,
-        noise_scale=<span class="n">16.0</span>, wear=(<span class="n">0.32</span>, <span class="n">0.16</span>, <span class="n">0.05</span>, <span class="n">1.0</span>),
-    )
-    metal = principled(
-        <span class="s">&quot;FenceIron&quot;</span>, (<span class="n">0.11</span>, <span class="n">0.115</span>, <span class="n">0.13</span>, <span class="n">1.0</span>), <span class="n">1.0</span>, <span class="n">0.28</span>,
-        noise_scale=<span class="n">20.0</span>, wear=(<span class="n">0.18</span>, <span class="n">0.16</span>, <span class="n">0.12</span>, <span class="n">1.0</span>),
-    )
+    paint_planks(low.data)
+    paint_planks(high.data)
+    wood, metal = fence_materials()
     assign_slots(low, wood, metal)
     assign_slots(high, wood, metal)
 
@@ -1117,6 +1394,9 @@ <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="c"># Measured; do not leave a .glb per run in the temp directory.</span>
+        os.remove(export_path)
 
     hyg = hygiene_audit(low.data)
     zf = zfight_pairs(low.data)
@@ -1150,6 +1430,10 @@ <h2>Source</h2>
         <span class="s">f&quot;</span><span class="s">shoe_z=</span>{jnt[<span class="s">&#x27;shoe_z&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> brace_gap=</span>{jnt[<span class="s">&#x27;brace_gap&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> </span><span class="s">&quot;</span>
         <span class="s">f&quot;</span><span class="s">rail_gap=</span>{jnt[<span class="s">&#x27;rail_gap&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> span_x=</span>{jnt[<span class="s">&#x27;span_x&#x27;</span>]:<span class="s">.4f</span>}<span class="s">&quot;</span>
     )
+    print(
+        <span class="s">f&quot;</span><span class="s">measured brace_post_bite=</span>{jnt[<span class="s">&#x27;brace_post_bite&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">brace_rail_bite=</span>{jnt[<span class="s">&#x27;brace_rail_bite&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> tile=</span>{TILE}<span class="s"> size_x=</span>{size_x:<span class="s">.4f</span>}<span class="s">&quot;</span>
+    )
 
     <span class="k">if</span> <span class="k">not</span> (BASE_TRIS_MIN &lt;= base_tris &lt;= BASE_TRIS_MAX):
         <span class="k">return</span> fail(
@@ -1207,6 +1491,21 @@ <h2>Source</h2>
             <span class="s">f&quot;</span><span class="s">rail span </span>{jnt[<span class="s">&#x27;span_x&#x27;</span>]:<span class="s">.4f</span>}<span class="s"> off </span>{<span class="n">2.0</span> * RAIL_HALF}<span class="s">&quot;</span>,
             <span class="n">19</span>,
         ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+    <span class="k">if</span> (
+        jnt[<span class="s">&quot;brace_post_bite&quot;</span>] &lt; BRACE_POST_BITE_MIN
+        <span class="k">or</span> jnt[<span class="s">&quot;brace_rail_bite&quot;</span>] &lt; BRACE_RAIL_BITE_MIN
+    ):
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">brace housing </span>{jnt[<span class="s">&#x27;brace_post_bite&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> &lt; </span>{BRACE_POST_BITE_MIN}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">f&quot;</span><span class="s">or rail bearing </span>{jnt[<span class="s">&#x27;brace_rail_bite&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> &lt; </span>{BRACE_RAIL_BITE_MIN}<span class="s">&quot;</span>,
+            <span class="n">20</span>,
+        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+    <span class="k">if</span> <span class="k">not</span> (TILE - TILE_FIT_TOL &lt;= size_x &lt;= TILE):
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">section width </span>{size_x:<span class="s">.4f</span>}<span class="s"> does not fit the </span>{TILE}<span class="s"> m tile </span><span class="s">&quot;</span>
+            <span class="s">f&quot;</span><span class="s">(band </span>{TILE - TILE_FIT_TOL:<span class="s">.3f</span>}<span class="s">-</span>{TILE}<span class="s">)</span><span class="s">&quot;</span>,
+            <span class="n">21</span>,
+        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
     <span class="k">if</span> (
         abs(size_x - OUTER_SIZE[<span class="n">0</span>]) &gt; BBOX_TOL
         <span class="k">or</span> abs(size_y - OUTER_SIZE[<span class="n">1</span>]) &gt; BBOX_TOL
@@ -1270,13 +1569,13 @@ <h2>Source</h2>
             ob.hide_render = <span class="k">True</span>
             ob.hide_viewport = <span class="k">True</span>
 
+    <span class="c"># Level on the floor: an X tilt sinks one face of the shoes.</span>
     low.rotation_euler.z = math.radians(-<span class="n">16.0</span>)
-    low.rotation_euler.x = math.radians(<span class="n">2.0</span>)
 
     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()
@@ -1370,6 +1669,8 @@ <h2>Source</h2>
     p.add_argument(<span class="s">&quot;--short-brace&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
     p.add_argument(<span class="s">&quot;--gap-rails&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
     p.add_argument(<span class="s">&quot;--long-rails&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--float-brace&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--wide-tile&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
     args = p.parse_args(argv)
 
     code, low, _high, wood, tex, _col = check(
@@ -1380,6 +1681,8 @@ <h2>Source</h2>
         short_shoes=args.short_shoes,
         gap_rails=args.gap_rails,
         long_rails=args.long_rails,
+        float_brace=args.float_brace,
+        wide_tile=args.wide_tile,
     )
     <span class="k">if</span> code:
         <span class="k">return</span> code
@@ -1404,7 +1707,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/fence-kit-hero.webp" alt="A section of wooden post-and-rail fence with a diagonal brace and dark iron collars." />
+    <img src="../assets/fence-kit-hero.webp" alt="A section of grained timber post-and-rail fence with a diagonal board brace across the rails and dark iron bands and shoes on both posts." />
   </dialog>
   <footer>
     <div class="statusbar">
diff --git a/docs/gallery/index.html b/docs/gallery/index.html
index 7f8efc46..7dcbe5eb 100644
--- a/docs/gallery/index.html
+++ b/docs/gallery/index.html
@@ -761,7 +761,7 @@ <h2><a href="prop-origin-transform/">prop-origin-transform</a></h2>
       </article>
       <article class="card" data-tags="bmesh mesh">
         <a class="card-media" href="soccer-ball-goldberg/" tabindex="-1" aria-hidden="true">
-          <img src="assets/soccer-ball-goldberg-hero.webp" alt="A white soccer ball with black pentagon panels, built as a smoothed Goldberg polyhedron." loading="lazy" decoding="async" />
+          <img src="assets/soccer-ball-goldberg-hero.webp" alt="A round white soccer ball with black pentagon panels and dark stitched seams outlining every white hexagon, built as a smoothed Goldberg polyhedron." loading="lazy" decoding="async" />
         </a>
         <div class="card-body">
           <h2><a href="soccer-ball-goldberg/">soccer-ball-goldberg</a></h2>
@@ -992,12 +992,12 @@ <h2><a href="terrain-scatter/">terrain-scatter</a></h2>
       </article>
       <article class="card" data-tags="mesh export showcase">
         <a class="card-media" href="fence-kit/" tabindex="-1" aria-hidden="true">
-          <img src="assets/fence-kit-hero.webp" alt="A section of wooden post-and-rail fence with a diagonal brace and dark iron collars." loading="lazy" decoding="async" />
+          <img src="assets/fence-kit-hero.webp" alt="A section of grained timber post-and-rail fence with a diagonal board brace across the rails and dark iron bands and shoes on both posts." loading="lazy" decoding="async" />
         </a>
         <div class="card-body">
           <h2><a href="fence-kit/">fence-kit</a></h2>
-          <p class="teaches">A procedural post-and-rail fence section whose brace is an oriented box between named post stations, 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: 1092 tris, two materials with 156 metal and 390 wood faces, UVs in 0..1 with zero AABB overlap, outer AABB 1.624×0.134×1.232 m, grounded zmin, 2 iron shoes, brace-to-post gap 2.4 mm on both posts, rail-to-post gap 0.93 mm, rail span 1.390 m, LOD ratios in band (5.2 COLLAPSE leaner on LOD2), convex collider 32 tris, hygiene all zero, non-empty glTF. --skip-decimate exits 9; --stray-vert 15; --lift-z/--short-shoes 16; --short-brace 17; --gap-rails 18; --long-rails 19.</p>
+          <p class="teaches">A procedural post-and-rail fence section that fits its 1.60 m tile, with one-shell iron bands and a board brace housed in both posts, 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: 1012 tris, two materials with 116 metal and 390 wood faces, UVs in 0..1 with zero AABB overlap, outer AABB 1.596×0.134×1.232 m inside the 1.60 m tile, grounded zmin, 2 iron shoes, brace housed 12 mm in both posts and bearing 2 mm on the middle rail, rail-to-post gap 0.93 mm, rail span 1.362 m, LOD ratios in band (5.2 COLLAPSE leaner on LOD2), convex collider 24 tris, hygiene all zero, non-empty glTF. --skip-decimate exits 9; --stray-vert 15; --lift-z/--short-shoes 16; --short-brace 17; --gap-rails 18; --long-rails 19; --float-brace 20; --wide-tile 21.</p>
           <a class="card-link" href="fence-kit/">View showcase piece<span class="sr-only"> fence-kit</span> <span aria-hidden="true">&rarr;</span></a>
         </div>
       </article>
@@ -1025,12 +1025,12 @@ <h2><a href="cart/">cart</a></h2>
       </article>
       <article class="card" data-tags="mesh export showcase">
         <a class="card-media" href="park-bench/" tabindex="-1" aria-hidden="true">
-          <img src="assets/park-bench-hero.webp" alt="A park bench of wooden slats on a wrought-iron frame with scrolled feet and armrests." loading="lazy" decoding="async" />
+          <img src="assets/park-bench-hero.webp" alt="A park bench of grained wooden slats with a reclined back, on a dark wrought-iron frame whose round-bar legs curl into scrolled feet, with armrests on curved brackets." loading="lazy" decoding="async" />
         </a>
         <div class="card-body">
           <h2><a href="park-bench/">park-bench</a></h2>
-          <p class="teaches">A procedural wrought-iron park bench with tangent tube scroll feet through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.</p>
-          <p class="witnesses"><span class="tag">witnesses</span> Recomputed: 2520 tris, two materials with 540 metal and 756 wood faces, UVs in 0..1 with zero AABB overlap, outer AABB 1.295×0.632×0.884 m, grounded zmin, 4 named toes, stretcher gap 1.2 mm, slat gap 0.3 mm, seat span 1.272 m, LOD ratios in band, convex collider 82 tris, hygiene zero, non-empty glTF. --skip-decimate exits 9; --stray-vert 15; --lift-z/--short-feet 16; --float-stretcher 17; --gap-slats 18; --narrow-seat 19.</p>
+          <p class="teaches">A procedural wrought-iron park bench whose legs are each one bent bar from scroll toe to reclined back, 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: 3272 tris, two materials with 1008 metal and 756 wood faces, UVs in 0..1 with zero AABB overlap, outer AABB 1.295×0.632×0.887 m, grounded zmin, 4 named toes, 4 legs each one bar from toe to seat, back reclined 12°, 28 slat and armrest bites of at least 2.0 mm, stretcher gap 1.1 mm, seat span 1.272 m, LOD ratios in band, convex collider 64 tris, hygiene zero, non-empty glTF. --skip-decimate exits 9; --stray-vert 15; --lift-z/--short-feet 16; --float-stretcher 17; --gap-slats 18; --narrow-seat/--upright-back 19; --float-slats 20; --split-feet 21.</p>
           <a class="card-link" href="park-bench/">View showcase piece<span class="sr-only"> park-bench</span> <span aria-hidden="true">&rarr;</span></a>
         </div>
       </article>
diff --git a/docs/gallery/park-bench/index.html b/docs/gallery/park-bench/index.html
index 73435f01..dd8ba4f7 100644
--- a/docs/gallery/park-bench/index.html
+++ b/docs/gallery/park-bench/index.html
@@ -4,25 +4,25 @@
   <meta charset="utf-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1" />
   <title>park-bench — Showcase — Blender Developer Tools</title>
-  <meta name="description" content="A procedural wrought-iron park bench with tangent tube scroll feet through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
+  <meta name="description" content="A procedural wrought-iron park bench whose legs are each one bent bar from scroll toe to reclined back, through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
   <link rel="canonical" href="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/park-bench/" />
   <link rel="icon" href="../../assets/favicon.svg" type="image/svg+xml" />
   <meta name="theme-color" content="#1a1b1e" />
   <meta name="color-scheme" content="dark" />
   <meta property="og:type" content="website" />
   <meta property="og:title" content="park-bench — Showcase — Blender Developer Tools" />
-  <meta property="og:description" content="A procedural wrought-iron park bench with tangent tube scroll feet through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
+  <meta property="og:description" content="A procedural wrought-iron park bench whose legs are each one bent bar from scroll toe to reclined back, through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
   <meta property="og:url" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/park-bench/" />
   <meta property="og:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/park-bench-hero.webp" />
   <meta property="og:image:width" content="1280" />
   <meta property="og:image:height" content="720" />
-  <meta property="og:image:alt" content="A park bench of wooden slats on a wrought-iron frame with scrolled feet and armrests." />
+  <meta property="og:image:alt" content="A park bench of grained wooden slats with a reclined back, on a dark wrought-iron frame whose round-bar legs curl into scrolled feet, with armrests on curved brackets." />
   <meta property="og:site_name" content="Blender Developer Tools" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="park-bench — Showcase — Blender Developer Tools" />
-  <meta name="twitter:description" content="A procedural wrought-iron park bench with tangent tube scroll feet through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
+  <meta name="twitter:description" content="A procedural wrought-iron park bench whose legs are each one bent bar from scroll toe to reclined back, through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
   <meta name="twitter:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/park-bench-hero.webp" />
-  <meta name="twitter:image:alt" content="A park bench of wooden slats on a wrought-iron frame with scrolled feet and armrests." />
+  <meta name="twitter:image:alt" content="A park bench of grained wooden slats with a reclined back, on a dark wrought-iron frame whose round-bar legs curl into scrolled feet, with armrests on curved brackets." />
   <style>
     /* fonts are deployed by the landing build (docs/fonts/) */
     @font-face { font-family: 'Barlow Condensed'; font-weight: 600; font-display: swap;
@@ -265,38 +265,39 @@
   </div>
   <header class="hero">
     <h1>park-bench</h1>
-    <p>A procedural wrought-iron park bench with tangent tube scroll feet through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.</p>
+    <p>A procedural wrought-iron park bench whose legs are each one bent bar from scroll toe to reclined back, 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 park bench of wooden slats on a wrought-iron frame with scrolled feet and armrests.">
-      <img src="../assets/park-bench-hero.webp" alt="A park bench of wooden slats on a wrought-iron frame with scrolled feet and armrests." width="1280" height="720" />
+    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: A park bench of grained wooden slats with a reclined back, on a dark wrought-iron frame whose round-bar legs curl into scrolled feet, with armrests on curved brackets.">
+      <img src="../assets/park-bench-hero.webp" alt="A park bench of grained wooden slats with a reclined back, on a dark wrought-iron frame whose round-bar legs curl into scrolled feet, with armrests on curved brackets." 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: 2520 tris, two materials with 540 metal and 756 wood faces, UVs in 0..1 with zero AABB overlap, outer AABB 1.295×0.632×0.884 m, grounded zmin, 4 named toes, stretcher gap 1.2 mm, slat gap 0.3 mm, seat span 1.272 m, LOD ratios in band, convex collider 82 tris, hygiene zero, non-empty glTF. --skip-decimate exits 9; --stray-vert 15; --lift-z/--short-feet 16; --float-stretcher 17; --gap-slats 18; --narrow-seat 19.</div>
+    <div class="callout"><span class="tag">witnesses</span> Recomputed: 3272 tris, two materials with 1008 metal and 756 wood faces, UVs in 0..1 with zero AABB overlap, outer AABB 1.295×0.632×0.887 m, grounded zmin, 4 named toes, 4 legs each one bar from toe to seat, back reclined 12°, 28 slat and armrest bites of at least 2.0 mm, stretcher gap 1.1 mm, seat span 1.272 m, LOD ratios in band, convex collider 64 tris, hygiene zero, non-empty glTF. --skip-decimate exits 9; --stray-vert 15; --lift-z/--short-feet 16; --float-stretcher 17; --gap-slats 18; --narrow-seat/--upright-back 19; --float-slats 20; --split-feet 21.</div>
     <div class="runline">
       <pre id="runCmd">blender --background --python showcase/park-bench/park_bench.py --</pre>
       <button class="copy-btn" id="copyRun" type="button">Copy</button>
     </div>
     <section class="detail-section md">
-<p>A showcase piece, not an example. Procedural wrought-iron park bench (quarter-circle tube scroll feet tangent to the posts, slatted seat and back, arm scrolls, wood arm caps) then the shipped pipeline: unique-cell UVs, Cycles high-to-low normal bake, LOD chain, convex collider, Unity glTF export.</p>
-<p>Posts, feet, stretchers and arms share named stations (<code>hx</code>, <code>hy</code>, <code>SEAT_Z</code>, <code>ARM_Z</code>, <code>SCROLL_R</code>). A foot is a 6-gon tube about <code>(hy ± R, R)</code> so it is tangent to the post at <code>z=R</code> and plants at <code>z=0</code>. The H-stretcher meets the posts at those stations; slats insert into the post volume without sharing corner verts with the seat rails.</p>
+<p>A showcase piece, not an example. A procedural wrought-iron park bench (round-bar legs bent in one piece from scroll toe to post, with the rear pair bending again into a reclined back; a slatted seat and back; armrests on quarter-round brackets), then 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>Every leg is one bar swept along one path: a quarter-circle toe about <code>(hy ± R, R)</code>, tangent to the post where it meets it, then the post, and at the back a 12° bend into the upright that carries the back slats. The seat slats bear on the side rails, the back slats on the uprights, and each armrest on its arm bar and the front leg&#x27;s tenon, each by a named bite. The H-stretcher meets the legs at the shared stations (<code>HX</code>, <code>HY</code>, <code>SEAT_Z</code>, <code>ARM_Z</code>, <code>SCROLL_R</code>, <code>BACK_TOP</code>).</p>
 <p>It asserts <strong>budget conformance</strong> of the generated result. It does not witness an API contract. &quot;It rendered without error&quot; is not a check.</p>
 <p><strong>Composes</strong> skills <code>mesh-editing-and-bmesh</code>, <code>bake-high-to-low</code>, <code>depsgraph-and-evaluated-data</code>, <code>engine-export-presets</code>, and snippets <code>bake_normal_high_to_low.py</code>, <code>setup_bake_target_image.py</code>, <code>lod_chain.py</code> / <code>decimate_to_budget.py</code>, <code>convex_hull_collider.py</code>, <code>export_preset_unity.py</code> (helpers copied, not imported as a package). Hygiene combinatorics match <code>examples/mesh-hygiene-audit</code> (copied, not imported).</p>
-<p>Intended size: 1.40 m sitting width, 0.50 m seat depth, 0.43 m seat height, 0.64 m arm height; outer AABB 1.295 × 0.632 × 0.884 m.</p>
+<p>Intended size: 1.40 m sitting width, 0.50 m seat depth, 0.43 m seat height, 0.64 m arm height, back reclined 12°. Outer AABB 1.295 × 0.632 × 0.887 m.</p>
 <h2>Budgets</h2>
-<p>Declared as named constants; every gate <strong>recomputes</strong> from the mesh, materials, UVs, evaluated LOD, collider, or export file.</p>
-<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>2200–4200</td><td>2520 / 2520 / 2520</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.2198</td></tr><tr><td>Materials</td><td>exactly 2 distinct, ≥48 metal, ≥24 wood</td><td>2 slots, 540 metal / 756 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.295, 0.632, 0.884) m ± 0.015</td><td>(1.2945, 0.6314, 0.8840), zmin 0</td></tr><tr><td>Collider tris</td><td>≤ 180</td><td>82</td></tr><tr><td>Export</td><td>written, size &gt; 0</td><td>188164 / 188164 / 188148 bytes</td></tr></tbody></table></div>
-<p>Base triangles rose from <strong>2100 to 2520</strong> in the quality pass: box-segment scrolls became 6-gon tubes. Outer AABB widened from 1.080 × 0.566 × 0.853 m to a 1.40 m sitting-width bench.</p>
-<p>DECIMATE COLLAPSE triangle counts are <strong>not</strong> guaranteed identical across series — the gate is a ratio band, not an exact count. This mesh matched on 4.5.11 / 5.1.2 / 5.2.1. Bake pixels are stochastic; the gate is <code>has_data</code> plus operator <code>FINISHED</code>, not byte-identity. Construction uses no RNG. Export byte counts differ by 16 B on 5.2.1 (glTF serializer), not a gated axis.</p>
+<p>Declared as named constants. Every gate <strong>recomputes</strong> its value 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>2900–3700</td><td>3272 / 3272 / 3272</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 2 distinct, ≥48 metal, ≥24 wood</td><td>2 slots, 1008 metal / 756 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.295, 0.632, 0.887) m ± 0.015</td><td>(1.2945, 0.6316, 0.8870), zmin 0</td></tr><tr><td>Collider tris</td><td>≤ 180</td><td>64</td></tr><tr><td>Export</td><td>written, size &gt; 0</td><td>245620 / 245620 / 245604 bytes</td></tr></tbody></table></div>
+<p>Base triangles rose from <strong>2520 to 3272</strong> in the second quality pass. The square posts and 6-gon scroll tubes became 8-gon round bar swept along each leg, the back gained its bend, and armrest brackets were added. The band was re-fitted around the measurement and narrowed from 2200–4200.</p>
+<p>DECIMATE COLLAPSE triangle counts are <strong>not</strong> guaranteed identical across series — the gate is a ratio band, not an exact count. This mesh matched on 4.5.11 / 5.1.2 / 5.2.1. Bake pixels are stochastic; the gate is <code>has_data</code> plus operator <code>FINISHED</code>, not byte-identity. Slat widths are closed-form and plank tones are seeded, so repeated runs on one binary print identical measurements. Export byte counts differ by 16 B on 5.2.1 (glTF serializer), not a gated axis.</p>
 <h3>Hygiene</h3>
 <p>Recomputed from the generated mesh, not asserted about the script.</p>
 <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 toes</td><td>4, each <code>zmin</code> ≤ 0.002</td><td>4, 0.00000</td></tr></tbody></table></div>
-<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>Stretcher-to-post BVH gap</td><td>≤ 0.008 m</td><td>0.00120</td></tr><tr><td>Slat-to-post BVH gap</td><td>≤ 0.008 m</td><td>0.00028</td></tr><tr><td>Seat span vs <code>2·hx</code></td><td>± 0.08 m</td><td>1.2720 vs 1.260</td></tr></tbody></table></div>
+<h3>Joint fit, bearing and form</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>Stretcher-to-leg BVH gap</td><td>≤ 0.008 m</td><td>0.00111</td></tr><tr><td>Slat-to-leg BVH gap</td><td>≤ 0.008 m</td><td>0.00016</td></tr><tr><td>Seat span vs <code>2·hx</code></td><td>± 0.08 m</td><td>1.2720 vs 1.260</td></tr><tr><td>Bearing bite (exit 20): 7 seat slats × 2 side rails, 5 back slats × 2 uprights, 2 armrests × (front leg + arm bar), overlap depth either way round</td><td>28 bites, each ≥ 0.0015 m</td><td>28, min 0.00201</td></tr><tr><td>Legs in one piece (exit 21): the shell under each toe station is a leg reaching the seat</td><td>4</td><td>4</td></tr><tr><td>Back recline (exit 19): each upright, from a low and a high slab centroid</td><td>9°–16°</td><td>12.00° / 12.00°</td></tr></tbody></table></div>
+<p>The bearing bite takes the overlap either way round. A round rail has vertices only at its end rings, so under a mid-span slat it is the slat&#x27;s corner that sits in the rail, not a rail vertex in the slat.</p>
 <h3>Falsifiers</h3>
 <p>Each violates one named budget. All were run on 4.5.11, 5.1.2 and 5.2.1 and returned the same code on each.</p>
-<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-feet</code></td><td>named toes plant at z=0</td><td>16</td></tr><tr><td><code>--float-stretcher</code></td><td>stretcher-to-post BVH gap</td><td>17</td></tr><tr><td><code>--gap-slats</code></td><td>slat-to-post BVH gap</td><td>18</td></tr><tr><td><code>--narrow-seat</code></td><td>seat span vs <code>2·hx</code></td><td>19</td></tr></tbody></table></div>
-<p><code>--short-feet</code> lifts only the outward toe verts. After recenter the post join is the AABB <code>zmin</code>, so the AABB gate would still pass; the named-toe stations fail.</p>
+<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-feet</code></td><td>named toes plant at z=0</td><td>16</td></tr><tr><td><code>--float-stretcher</code></td><td>stretcher-to-leg BVH gap</td><td>17</td></tr><tr><td><code>--gap-slats</code></td><td>slat-to-leg BVH gap</td><td>18</td></tr><tr><td><code>--narrow-seat</code></td><td>seat span vs <code>2·hx</code></td><td>19</td></tr><tr><td><code>--upright-back</code></td><td>back recline band (measured 0.00°)</td><td>19</td></tr><tr><td><code>--float-slats</code></td><td>bearing bite (seat slats 6 mm up; measured −0.00354)</td><td>20</td></tr><tr><td><code>--split-feet</code></td><td>legs in one piece (measured 0 of 4)</td><td>21</td></tr></tbody></table></div>
+<p><code>--short-feet</code> lifts only the outward toe verts. After recentring, the bottom of the scroll is the AABB <code>zmin</code>, so the AABB gate would still pass. The named-toe stations fail. <code>--split-feet</code> restores the first build: each foot is an arc stopped short of its post, and each post starts at the arc&#x27;s top. The toes still ground and every gap budget still passes. Only the one-piece budget sees the 14 mm of daylight. <code>--upright-back</code> keeps the back top where it was, so the envelope does not move.</p>
 <h2>Run</h2>
 <pre><code>blender --background --python park_bench.py --
 blender --background --python park_bench.py -- --skip-decimate
@@ -306,11 +307,14 @@ <h2>Run</h2>
 blender --background --python park_bench.py -- --float-stretcher
 blender --background --python park_bench.py -- --gap-slats
 blender --background --python park_bench.py -- --narrow-seat
+blender --background --python park_bench.py -- --upright-back
+blender --background --python park_bench.py -- --float-slats
+blender --background --python park_bench.py -- --split-feet
 blender --background --python park_bench.py -- --output bench.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 ≠ 2 distinct slots, or wood/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 (<code>--stray-vert</code> lands here)</td></tr><tr><td>16</td><td>Grounded zmin / named toes (<code>--lift-z</code>, <code>--short-feet</code>)</td></tr><tr><td>17</td><td>Stretcher-to-post gap (<code>--float-stretcher</code>)</td></tr><tr><td>18</td><td>Slat-to-post gap (<code>--gap-slats</code>)</td></tr><tr><td>19</td><td>Seat span (<code>--narrow-seat</code>)</td></tr></tbody></table></div>
+<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. <code>20</code> and <code>21</code> are this piece&#x27;s own.</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 wood/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 (<code>--stray-vert</code> lands here)</td></tr><tr><td>16</td><td>Grounded zmin / named toes (<code>--lift-z</code>, <code>--short-feet</code>)</td></tr><tr><td>17</td><td>Stretcher-to-leg gap (<code>--float-stretcher</code>)</td></tr><tr><td>18</td><td>Slat-to-leg gap (<code>--gap-slats</code>)</td></tr><tr><td>19</td><td>Seat span (<code>--narrow-seat</code>) or back recline (<code>--upright-back</code>)</td></tr><tr><td>20</td><td>Bearing bite on slats and armrests (<code>--float-slats</code>)</td></tr><tr><td>21</td><td>Legs not bent in one piece from toe to seat (<code>--split-feet</code>)</td></tr></tbody></table></div>
     </section>
     <section class="detail-section src">
       <h2>Source</h2>
@@ -320,23 +324,27 @@ <h2>Source</h2>
       </div>
       <pre><span class="s">&quot;&quot;&quot;Game-ready park bench — a showcase piece, not an example.
 
-Asserts budget conformance of a procedural wrought-iron bench (quarter-
-circle scroll feet tangent to the posts, slatted seat and back, arm
-scrolls) after composing shipped pipeline pieces: bmesh construction,
-UVs, two materials, high-to-low normal bake, LOD chain, convex collider,
-Unity glTF export.
+Asserts budget conformance of a procedural wrought-iron bench after
+composing shipped pipeline pieces: bmesh construction, UVs, two
+materials, high-to-low normal bake, LOD chain, convex collider, Unity
+glTF export.
 
-Posts, feet, stretchers and arms share named stations (hx, hy, SEAT_Z,
-ARM_Z, SCROLL_R). A foot is a quarter-circle about (hy ± R, R) so it is
-tangent to the post at z=R and plants at z=0.
+Every leg is one round bar swept along one path: a quarter-circle toe
+scroll about (hy ± R, R), the post, and at the back a bend into the
+reclined upright that carries the back slats. Seat slats bear on the side
+rails, back slats on the uprights, armrests on the arm bar and the front
+leg&#x27;s tenon, each by a named bite. Stations are shared (HX, HY, SEAT_Z,
+ARM_Z, SCROLL_R, BACK_TOP).
 
 Budgets are declared below and recomputed from the generated result.
 They are not API-contract witnesses. Each falsifier violates one named
 budget: ``--skip-decimate`` LOD, ``--stray-vert`` hygiene, ``--lift-z``
 zmin, ``--short-feet`` named toes, ``--float-stretcher`` stretcher seat,
-``--gap-slats`` slat-to-rail, ``--narrow-seat`` sitting width.
+``--gap-slats`` slat-to-leg, ``--narrow-seat`` sitting width,
+``--float-slats`` bearing bite (20), ``--split-feet`` legs in one piece
+(21), ``--upright-back`` back recline (19).
 
-No RNG. Slat widths use closed-form ``sin(i)``. DECIMATE COLLAPSE
+Slat widths use closed-form ``sin(i)``; plank tones use a seeded RNG. DECIMATE COLLAPSE
 triangle counts are not byte-identical across Blender versions — the LOD
 gate is a ratio band, not an exact count.
 
@@ -347,6 +355,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
@@ -378,15 +387,31 @@ <h2>Source</h2>
 STRETCHER_Z = <span class="n">0.16</span>
 POST_INSET_X = <span class="n">0.07</span>
 POST_INSET_Y = <span class="n">0.045</span>
+BAR_R = IRON_T / <span class="n">2.0</span>
+TUBE_SEGS = <span class="n">8</span>
+RECLINE_DEG = <span class="n">12.0</span>
+BEND_R = <span class="n">0.10</span>
+BEND_N = <span class="n">4</span>
+UPRIGHT_N = <span class="n">4</span>
+TOP_RAIL_R = BAR_R * <span class="n">1.25</span>
+BACK_TOP = SEAT_Z + SLAT_T + BACK_H + <span class="n">0.02</span>
+BACK_CLEAR = <span class="n">0.012</span>
+SLAT_BITE = <span class="n">0.003</span>
+ARM_OVER = <span class="n">0.075</span>
+ARM_TENON = <span class="n">0.004</span>
+LEG_TENON = <span class="n">0.012</span>
+BRACKET_R = <span class="n">0.05</span>
+BRACKET_N = <span class="n">8</span>
+BRACKET_BITE = <span class="n">0.008</span>
 HX = SEAT_W / <span class="n">2.0</span> - POST_INSET_X
 HY = SEAT_D / <span class="n">2.0</span> - POST_INSET_Y
 SEAT_SPAN = <span class="n">2.0</span> * HX
 SEAT_SPAN_TOL = <span class="n">0.08</span>
 
 BBOX_TOL = <span class="n">0.015</span>
-OUTER_SIZE = (<span class="n">1.295</span>, <span class="n">0.632</span>, <span class="n">0.884</span>)
-BASE_TRIS_MIN = <span class="n">2200</span>
-BASE_TRIS_MAX = <span class="n">4200</span>
+OUTER_SIZE = (<span class="n">1.295</span>, <span class="n">0.632</span>, <span class="n">0.887</span>)
+BASE_TRIS_MIN = <span class="n">2900</span>
+BASE_TRIS_MAX = <span class="n">3700</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>
@@ -415,6 +440,14 @@ <h2>Source</h2>
 SHORT_FOOT = <span class="n">0.16</span>
 LIFT_Z = <span class="n">0.05</span>
 NARROW_SEAT = <span class="n">0.55</span>
+LEG_COUNT = <span class="n">4</span>
+BITE_MIN = <span class="n">0.0015</span>
+FLOAT_SLATS = <span class="n">0.006</span>
+RECLINE_MIN_DEG = <span class="n">9.0</span>
+RECLINE_MAX_DEG = <span class="n">16.0</span>
+PLANK_TONE_JITTER = <span class="n">0.28</span>
+TONE_SEED = <span class="n">23</span>
+WOOD_GRAIN_SCALE = <span class="n">30.0</span>
 
 WOOD_IDX = <span class="n">0</span>
 METAL_IDX = <span class="n">1</span>
@@ -484,70 +517,89 @@ <h2>Source</h2>
     )
 
 
-<span class="k">def</span> add_arc_yz(bm, x, cy, cz, radius, a0, a1, n, thick, mat_idx, t0=<span class="n">0.0</span>, t1=<span class="n">1.0</span>):
-    pts = []
-    <span class="k">for</span> i <span class="k">in</span> range(n + <span class="n">1</span>):
-        t = t0 + (t1 - t0) * (i / n)
-        ang = a0 + (a1 - a0) * t
-        pts.append(Vector((x, cy + radius * math.cos(ang), cz + radius * math.sin(ang))))
-    rings = <span class="n">6</span>
-    r = thick * <span class="n">0.5</span>
-    ring_verts = []
-    <span class="k">for</span> i, p <span class="k">in</span> enumerate(pts):
-        <span class="k">if</span> i &lt; n:
-            tangent = (pts[i + <span class="n">1</span>] - p).normalized()
+<span class="k">def</span> add_sweep(bm, pts, radius, mat_idx, segs=<span class="k">None</span>):
+    <span class="s">&quot;&quot;&quot;Round bar along a polyline, parallel-transported frames, fan caps.
+
+    Every leg is one sweep: the toe scroll, the post and (at the back) the
+    reclined upright are a single bar, the way a smith bends it. A foot
+    built as its own arc under a separate post leaves daylight at the join.
+    &quot;&quot;&quot;</span>
+    segs = segs <span class="k">or</span> TUBE_SEGS
+    pts = [Vector(p) <span class="k">for</span> p <span class="k">in</span> pts]
+    n = len(pts)
+    tangents = []
+    <span class="k">for</span> i <span class="k">in</span> range(n):
+        <span class="k">if</span> i == <span class="n">0</span>:
+            t = pts[<span class="n">1</span>] - pts[<span class="n">0</span>]
+        <span class="k">elif</span> i == n - <span class="n">1</span>:
+            t = pts[-<span class="n">1</span>] - pts[-<span class="n">2</span>]
         <span class="k">else</span>:
-            tangent = (p - pts[i - <span class="n">1</span>]).normalized()
-        side = tangent.cross(Vector((<span class="n">1.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>)))
-        <span class="k">if</span> side.length &lt; <span class="n">1e-6</span>:
-            side = tangent.cross(Vector((<span class="n">0.0</span>, <span class="n">1.0</span>, <span class="n">0.0</span>)))
-        side.normalize()
-        up = tangent.cross(side).normalized()
+            t = (pts[i + <span class="n">1</span>] - pts[i]).normalized() + (pts[i] - pts[i - <span class="n">1</span>]).normalized()
+        tangents.append(t.normalized())
+    t0 = tangents[<span class="n">0</span>]
+    ref = Vector((<span class="n">1.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>)) <span class="k">if</span> abs(t0.x) &lt; <span class="n">0.9</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>))
+    side = t0.cross(ref).normalized()
+    rings = []
+    <span class="k">for</span> i, p <span class="k">in</span> enumerate(pts):
+        t = tangents[i]
+        <span class="k">if</span> i &gt; <span class="n">0</span>:
+            side = tangents[i - <span class="n">1</span>].rotation_difference(t) @ side
+            side = (side - t * side.dot(t)).normalized()
+        up = t.cross(side).normalized()
         ring = []
-        <span class="k">for</span> k <span class="k">in</span> range(rings):
-            ang = (<span class="n">2.0</span> * math.pi * k) / rings
-            offset = side * math.cos(ang) * r + up * math.sin(ang) * r
-            ring.append(bm.verts.new(p + offset))
-        ring_verts.append(ring)
-    bm.verts.ensure_lookup_table()
-    bm.faces.ensure_lookup_table()
-    <span class="k">for</span> a, b <span class="k">in</span> zip(ring_verts, ring_verts[<span class="n">1</span>:]):
-        <span class="k">for</span> k <span class="k">in</span> range(rings):
-            k2 = (k + <span class="n">1</span>) % rings
-            face = bm.faces.new((a[k], a[k2], b[k2], b[k]))
-            face.material_index = mat_idx
-    <span class="k">for</span> end_i, p <span class="k">in</span> ((<span class="n">0</span>, pts[<span class="n">0</span>]), (-<span class="n">1</span>, pts[-<span class="n">1</span>])):
-        center = bm.verts.new(p)
-        ring = ring_verts[end_i]
-        <span class="k">for</span> k <span class="k">in</span> range(rings):
-            k2 = (k + <span class="n">1</span>) % rings
-            <span class="k">if</span> end_i == <span class="n">0</span>:
-                face = bm.faces.new((center, ring[k2], ring[k]))
-            <span class="k">else</span>:
-                face = bm.faces.new((center, ring[k], ring[k2]))
-            face.material_index = mat_idx
-    <span class="k">return</span> [v <span class="k">for</span> ring <span class="k">in</span> ring_verts <span class="k">for</span> v <span class="k">in</span> ring]
-
-
-<span class="k">def</span> add_foot_scroll(bm, x, y_post, y_out, thick, mat_idx):
-    <span class="s">&quot;&quot;&quot;Quarter-circle from post join (y_post, R) to toe (y_out, 0).&quot;&quot;&quot;</span>
-    cy = y_out
-    cz = SCROLL_R
-    <span class="k">if</span> y_out &lt; y_post:
-        a0, a1 = <span class="n">0.0</span>, -math.pi / <span class="n">2.0</span>
-    <span class="k">else</span>:
-        a0, a1 = math.pi, <span class="n">1.5</span> * math.pi
-    <span class="k">return</span> add_arc_yz(
-        bm, x, cy, cz, SCROLL_R, a0, a1, SCROLL_N, thick, mat_idx, t0=<span class="n">0.08</span>, t1=<span class="n">1.0</span>
-    )
-
-
-<span class="k">def</span> add_arm_scroll(bm, x, y_post, thick, mat_idx):
-    cy = y_post - ARM_SCROLL_R
-    cz = ARM_Z
-    <span class="k">return</span> add_arc_yz(
-        bm, x, cy, cz, ARM_SCROLL_R, <span class="n">0.0</span>, -math.pi / <span class="n">2.0</span>, <span class="n">8</span>, thick, mat_idx, t0=<span class="n">0.08</span>, t1=<span class="n">1.0</span>
-    )
+        <span class="k">for</span> k <span class="k">in</span> range(segs):
+            a = <span class="n">2.0</span> * math.pi * k / segs
+            ring.append(bm.verts.new(p + (side * math.cos(a) + up * math.sin(a)) * radius))
+        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(segs):
+            k2 = (k + <span class="n">1</span>) % segs
+            bm.faces.new((a[k], a[k2], b[k2], b[k])).material_index = mat_idx
+    <span class="k">for</span> ring, p, flip <span class="k">in</span> ((rings[<span class="n">0</span>], pts[<span class="n">0</span>], <span class="k">True</span>), (rings[-<span class="n">1</span>], pts[-<span class="n">1</span>], <span class="k">False</span>)):
+        c = bm.verts.new(p)
+        <span class="k">for</span> k <span class="k">in</span> range(segs):
+            k2 = (k + <span class="n">1</span>) % segs
+            f = bm.faces.new((c, ring[k2], ring[k]) <span class="k">if</span> flip <span class="k">else</span> (c, ring[k], ring[k2]))
+            f.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> toe_arc(y_post, outward):
+    <span class="s">&quot;&quot;&quot;Quarter circle from the toe (on the floor) up to the post at z=R.
+
+    Centre ``(y_post + outward*R, R)``: horizontal at the toe, tangent to
+    the post where it meets it. Returned toe first.
+    &quot;&quot;&quot;</span>
+    cy = y_post + outward * SCROLL_R
+    pts = []
+    <span class="k">for</span> i <span class="k">in</span> range(SCROLL_N + <span class="n">1</span>):
+        a = -<span class="n">0.5</span> * math.pi * (<span class="n">1.0</span> - i / SCROLL_N)
+        pts.append((cy - outward * SCROLL_R * math.cos(a), SCROLL_R + SCROLL_R * math.sin(a)))
+    <span class="k">return</span> pts
+
+
+<span class="k">def</span> rear_leg_path(recline):
+    <span class="s">&quot;&quot;&quot;(y, z) centreline of a rear leg: toe, post, bend, reclined upright.&quot;&quot;&quot;</span>
+    pts = toe_arc(HY, <span class="n">1.0</span>)
+    pts.append((HY, SEAT_Z))
+    <span class="c"># No bend at zero recline: its points would all land on one spot.</span>
+    <span class="k">for</span> i <span class="k">in</span> range(<span class="n">1</span>, BEND_N + <span class="n">1</span> <span class="k">if</span> recline &gt; <span class="n">0.0</span> <span class="k">else</span> <span class="n">1</span>):
+        ph = recline * i / BEND_N
+        pts.append((HY + BEND_R * (<span class="n">1.0</span> - math.cos(ph)), SEAT_Z + BEND_R * math.sin(ph)))
+    y_f, z_f = pts[-<span class="n">1</span>]
+    y_t = y_f + (BACK_TOP - z_f) * math.tan(recline)
+    <span class="k">for</span> i <span class="k">in</span> range(<span class="n">1</span>, UPRIGHT_N + <span class="n">1</span>):
+        f = i / UPRIGHT_N
+        pts.append((y_f + (y_t - y_f) * f, z_f + (BACK_TOP - z_f) * f))
+    <span class="k">return</span> pts
+
+
+<span class="k">def</span> path_y_at(path, z):
+    <span class="s">&quot;&quot;&quot;y of a (y, z) path where it first crosses height z.&quot;&quot;&quot;</span>
+    <span class="k">for</span> (y0, z0), (y1, z1) <span class="k">in</span> zip(path, path[<span class="n">1</span>:]):
+        <span class="k">if</span> (z0 - z) * (z1 - z) &lt;= <span class="n">0.0</span> <span class="k">and</span> abs(z1 - z0) &gt; <span class="n">1e-9</span>:
+            <span class="k">return</span> y0 + (y1 - y0) * (z - z0) / (z1 - z0)
+    <span class="k">return</span> path[-<span class="n">1</span>][<span class="n">0</span>]
 
 
 <span class="k">def</span> pack_uvs(bm, margin=<span class="n">0.08</span>):
@@ -601,18 +653,28 @@ <h2>Source</h2>
     gap_slats=<span class="k">False</span>,
     short_feet=<span class="k">False</span>,
     narrow_seat=<span class="k">False</span>,
+    float_slats=<span class="k">False</span>,
+    split_feet=<span class="k">False</span>,
+    upright_back=<span class="k">False</span>,
 ):
     bm = bmesh.new()
     <span class="k">try</span>:
         wood = []
         t = IRON_T
+        r = BAR_R
         hx, hy = HX, HY
+        recline = <span class="n">0.0</span> <span class="k">if</span> upright_back <span class="k">else</span> math.radians(RECLINE_DEG)
+        rear = rear_leg_path(recline)
         slat_span = SEAT_SPAN + t * <span class="n">0.50</span>
         <span class="k">if</span> gap_slats:
             slat_span = SEAT_SPAN - IRON_T - <span class="n">0.024</span>
         <span class="k">if</span> narrow_seat:
             slat_span = SEAT_SPAN * NARROW_SEAT
 
+        <span class="c"># Seat slats bear on the side rails: the bottom face sits a named</span>
+        <span class="c"># bite below the rail&#x27;s top line, so each slat is carried.</span>
+        rail_z = SEAT_Z - t * <span class="n">0.35</span>
+        slat_z0 = rail_z + r - SLAT_BITE + (FLOAT_SLATS <span class="k">if</span> float_slats <span class="k">else</span> <span class="n">0.0</span>)
         usable = <span class="n">2.0</span> * hy - <span class="n">0.06</span>
         gap = <span class="n">0.010</span>
         widths = []
@@ -626,43 +688,62 @@ <h2>Source</h2>
             wood.extend(
                 add_box(
                     bm,
-                    (<span class="n">0.0</span>, y, SEAT_Z + SLAT_T / <span class="n">2.0</span>),
+                    (<span class="n">0.0</span>, y, slat_z0 + SLAT_T / <span class="n">2.0</span>),
                     (slat_span, slat_w * <span class="n">0.92</span>, SLAT_T),
                     WOOD_IDX,
                 )
             )
             y_cursor += slat_w + gap
 
-        back_span = BACK_H - <span class="n">0.04</span>
+        <span class="c"># Back slats are screwed to the front of the reclined uprights.</span>
+        y_f, z_f = rear[-<span class="n">1</span> - UPRIGHT_N]
+        y_top, z_top = rear[-<span class="n">1</span>]
+        u = Vector((<span class="n">0.0</span>, y_top - y_f, z_top - z_f))
+        run = u.length
+        u.normalize()
+        fwd = Vector((<span class="n">0.0</span>, -u.z, u.y))
+        base = Vector((<span class="n">0.0</span>, y_f, z_f))
+        d0 = max(<span class="n">0.0</span>, (SEAT_Z + SLAT_T + <span class="n">0.04</span> - z_f) / max(u.z, <span class="n">1e-6</span>))
+        d1 = run - r - BACK_CLEAR
         bwidths = [<span class="n">1.0</span> + <span class="n">0.08</span> * math.sin(i * <span class="n">1.4</span> + <span class="n">0.8</span>) <span class="k">for</span> i <span class="k">in</span> range(N_BACK)]
-        bscale = (back_span - gap * (N_BACK - <span class="n">1</span>)) / sum(bwidths)
-        z_cursor = SEAT_Z + SLAT_T + <span class="n">0.04</span>
+        bscale = ((d1 - d0) - gap * (N_BACK - <span class="n">1</span>)) / sum(bwidths)
+        d_cursor = d0
+        off = r + SLAT_T / <span class="n">2.0</span> - SLAT_BITE
         <span class="k">for</span> w <span class="k">in</span> bwidths:
             slat_h = w * bscale
-            z = z_cursor + slat_h * <span class="n">0.5</span>
+            c = base + u * (d_cursor + slat_h * <span class="n">0.5</span>) + fwd * off
             wood.extend(
                 add_box(
                     bm,
-                    (<span class="n">0.0</span>, hy, z),
+                    tuple(c),
                     (slat_span, SLAT_T, slat_h * <span class="n">0.90</span>),
                     WOOD_IDX,
+                    euler=(-recline, <span class="n">0.0</span>, <span class="n">0.0</span>),
                 )
             )
-            z_cursor += slat_h + gap
-
+            d_cursor += slat_h + gap
+
+        <span class="c"># Armrests sit on the arm bar, overhang the front leg, and stop a</span>
+        <span class="c"># named tenon inside the reclined upright at their top edge.</span>
+        arm_bot = ARM_Z + r * <span class="n">0.95</span> - SLAT_BITE
+        arm_top = arm_bot + SLAT_T
+        y_arm_end = path_y_at(rear, arm_top) - r / math.cos(recline) + ARM_TENON
+        y_arm_0 = -hy - ARM_OVER
         <span class="k">for</span> xsign <span class="k">in</span> (-<span class="n">1.0</span>, <span class="n">1.0</span>):
-            x = xsign * hx
             wood.extend(
                 add_box(
                     bm,
-                    (x, <span class="n">0.0</span>, ARM_Z + t * <span class="n">0.5</span> + SLAT_T * <span class="n">0.5</span>),
-                    (SLAT_T * <span class="n">1.15</span>, <span class="n">2.0</span> * hy + t, SLAT_T),
+                    (xsign * hx, <span class="n">0.5</span> * (y_arm_0 + y_arm_end), arm_bot + SLAT_T * <span class="n">0.5</span>),
+                    (SLAT_T * <span class="n">1.15</span>, y_arm_end - y_arm_0, SLAT_T),
                     WOOD_IDX,
                 )
             )
 
         <span class="k">if</span> bevel_offset &gt; <span class="n">0.0</span>:
-            edges = list({e <span class="k">for</span> v <span class="k">in</span> wood <span class="k">for</span> e <span class="k">in</span> v.link_edges})
+            <span class="c"># A set of BMEdges iterates in memory order; sort by index so the</span>
+            <span class="c"># bevel lays its faces down in the same order every run.</span>
+            bm.edges.index_update()
+            edges = sorted({e <span class="k">for</span> v <span class="k">in</span> wood <span class="k">for</span> e <span class="k">in</span> v.link_edges}, key=<span class="k">lambda</span> e: e.index)
             ret = bmesh.ops.bevel(
                 bm,
                 geom=edges,
@@ -675,57 +756,59 @@ <h2>Source</h2>
             <span class="k">for</span> f <span class="k">in</span> ret.get(<span class="s">&quot;faces&quot;</span>) <span class="k">or</span> []:
                 f.material_index = WOOD_IDX
 
-        add_box(bm, (<span class="n">0.0</span>, -hy, SEAT_Z - t * <span class="n">0.35</span>), (SEAT_SPAN, t, t), METAL_IDX)
-        add_box(bm, (<span class="n">0.0</span>, hy, SEAT_Z - t * <span class="n">0.35</span>), (SEAT_SPAN, t, t), METAL_IDX)
+        leg_top = arm_bot + LEG_TENON
         <span class="k">for</span> xsign <span class="k">in</span> (-<span class="n">1.0</span>, <span class="n">1.0</span>):
-            add_box(
+            x = xsign * hx
+            front = toe_arc(-hy, -<span class="n">1.0</span>)
+            <span class="k">if</span> split_feet:
+                <span class="c"># The first build: foot arcs that stop short of the posts,</span>
+                <span class="c"># and posts that start at z=R, as separate shells.</span>
+                add_sweep(bm, [(x, y, z) <span class="k">for</span> y, z <span class="k">in</span> front[:-<span class="n">1</span>]], r, METAL_IDX)
+                add_sweep(bm, [(x, -hy, SCROLL_R), (x, -hy, leg_top)], r, METAL_IDX)
+                add_sweep(bm, [(x, y, z) <span class="k">for</span> y, z <span class="k">in</span> rear[:SCROLL_N]], r, METAL_IDX)
+                add_sweep(bm, [(x, y, z) <span class="k">for</span> y, z <span class="k">in</span> rear[SCROLL_N:]], r, METAL_IDX)
+            <span class="k">else</span>:
+                front.append((-hy, leg_top))
+                add_sweep(bm, [(x, y, z) <span class="k">for</span> y, z <span class="k">in</span> front], r, METAL_IDX)
+                add_sweep(bm, [(x, y, z) <span class="k">for</span> y, z <span class="k">in</span> rear], r, METAL_IDX)
+            add_sweep(
                 bm,
-                (xsign * hx, <span class="n">0.0</span>, SEAT_Z - t * <span class="n">0.35</span>),
-                (t, <span class="n">2.0</span> * hy, t),
+                [(x, -hy, ARM_Z), (x, path_y_at(rear, ARM_Z), ARM_Z)],
+                r * <span class="n">0.95</span>,
                 METAL_IDX,
             )
-
-        back_top = SEAT_Z + SLAT_T + BACK_H + <span class="n">0.02</span>
-        <span class="k">for</span> xsign <span class="k">in</span> (-<span class="n">1.0</span>, <span class="n">1.0</span>):
-            x = xsign * hx
-            add_oriented_box(
-                bm, (x, hy, SCROLL_R), (x, hy, back_top), (t, t), METAL_IDX
-            )
-            add_oriented_box(
-                bm, (x, -hy, SCROLL_R), (x, -hy, ARM_Z), (t, t), METAL_IDX
-            )
-            add_oriented_box(
-                bm, (x, -hy, ARM_Z), (x, hy, ARM_Z), (t * <span class="n">0.95</span>, t * <span class="n">0.95</span>), METAL_IDX
-            )
-            add_foot_scroll(bm, x, -hy, -hy - SCROLL_R, t, METAL_IDX)
-            add_foot_scroll(bm, x, hy, hy + SCROLL_R, t, METAL_IDX)
-            add_arm_scroll(bm, x, -hy, t * <span class="n">0.90</span>, METAL_IDX)
-
-        add_box(bm, (<span class="n">0.0</span>, hy, back_top), (SEAT_SPAN, t, t), METAL_IDX)
+            <span class="c"># Quarter-round bracket under the armrest&#x27;s overhang: one end in</span>
+            <span class="c"># the leg, the other up inside the armrest.</span>
+            zc = arm_bot + BRACKET_BITE
+            br = []
+            <span class="k">for</span> i <span class="k">in</span> range(BRACKET_N + <span class="n">1</span>):
+                a = <span class="n">1.5</span> * math.pi - <span class="n">0.5</span> * math.pi * i / BRACKET_N
+                br.append((x, -hy + BRACKET_R * math.cos(a), zc + BRACKET_R * math.sin(a)))
+            add_sweep(bm, br, r * <span class="n">0.85</span>, METAL_IDX)
+            <span class="c"># Side seat rail, leg axis to leg axis.</span>
+            add_sweep(bm, [(x, -hy, rail_z), (x, hy, rail_z)], r, METAL_IDX)
+
+        <span class="c"># Front and back rails stop half a bar inside the legs: ending on the</span>
+        <span class="c"># leg axis puts their end rings on the side rails&#x27; end rings.</span>
+        rx = hx - <span class="n">0.5</span> * r
+        add_sweep(bm, [(-rx, -hy, rail_z), (rx, -hy, rail_z)], r, METAL_IDX)
+        add_sweep(bm, [(-rx, hy, rail_z), (rx, hy, rail_z)], r, METAL_IDX)
+        <span class="c"># The top rail runs through the upright tops, a heavier bar that</span>
+        <span class="c"># swallows their end caps, out to the armrests&#x27; outer faces.</span>
+        tx = hx + SLAT_T * <span class="n">1.15</span> * <span class="n">0.5</span>
+        add_sweep(bm, [(-tx, y_top, z_top), (tx, y_top, z_top)], TOP_RAIL_R, METAL_IDX)
 
         st_trim = FLOAT_STRETCHER <span class="k">if</span> float_stretcher <span class="k">else</span> <span class="n">0.0</span>
         yx = hx - st_trim
-        add_oriented_box(
-            bm,
-            (-yx, -hy, STRETCHER_Z),
-            (-yx, hy, STRETCHER_Z),
-            (t * <span class="n">0.9</span>, t * <span class="n">0.9</span>),
-            METAL_IDX,
-        )
-        add_oriented_box(
-            bm,
-            (yx, -hy, STRETCHER_Z),
-            (yx, hy, STRETCHER_Z),
-            (t * <span class="n">0.9</span>, t * <span class="n">0.9</span>),
-            METAL_IDX,
-        )
-        cx_end = yx - t * <span class="n">0.40</span>
-        add_oriented_box(
-            bm,
-            (-cx_end, <span class="n">0.0</span>, STRETCHER_Z),
-            (cx_end, <span class="n">0.0</span>, STRETCHER_Z),
-            (t * <span class="n">0.9</span>, t * <span class="n">0.9</span>),
-            METAL_IDX,
+        <span class="k">for</span> xsign <span class="k">in</span> (-<span class="n">1.0</span>, <span class="n">1.0</span>):
+            add_sweep(
+                bm,
+                [(xsign * yx, -hy, STRETCHER_Z), (xsign * yx, hy, STRETCHER_Z)],
+                r * <span class="n">0.9</span>,
+                METAL_IDX,
+            )
+        add_sweep(
+            bm, [(-yx, <span class="n">0.0</span>, STRETCHER_Z), (yx, <span class="n">0.0</span>, STRETCHER_Z)], r * <span class="n">0.9</span>, METAL_IDX
         )
 
         <span class="k">if</span> short_feet:
@@ -751,13 +834,12 @@ <h2>Source</h2>
             bmesh.ops.triangulate(bm, faces=ngons)
         pack_uvs(bm)
         bmesh.ops.recalc_face_normals(bm, faces=list(bm.faces))
-        <span class="k">for</span> face <span class="k">in</span> bm.faces:
-            face.smooth = face.material_index == METAL_IDX
         me = bpy.data.meshes.new(name)
         bm.to_mesh(me)
         me.update()
+        <span class="c"># Round bar is smooth-shaded; sawn slats keep their chamfer facets.</span>
         <span class="k">for</span> poly <span class="k">in</span> me.polygons:
-            poly.use_smooth = poly.material_index == METAL_IDX
+            poly.use_smooth = poly.material_index == METAL_IDX <span class="k">and</span> len(poly.vertices) == <span class="n">4</span>
     <span class="k">finally</span>:
         bm.free()
     out = bpy.data.objects.new(name, me)
@@ -784,9 +866,142 @@ <h2>Source</h2>
         fac = mix.inputs.get(<span class="s">&quot;Factor&quot;</span>) <span class="k">or</span> mix.inputs.get(<span class="s">&quot;Fac&quot;</span>)
         nt.links.new(tex.outputs[<span class="s">&quot;Fac&quot;</span>], fac)
         nt.links.new(mix.outputs[<span class="s">&quot;Result&quot;</span>], bsdf.inputs[<span class="s">&quot;Base Color&quot;</span>])
+        rmix = nt.nodes.new(<span class="s">&quot;ShaderNodeMix&quot;</span>)
+        rmix.data_type = <span class="s">&quot;FLOAT&quot;</span>
+        rmix.inputs[<span class="s">&quot;A&quot;</span>].default_value = roughness
+        rmix.inputs[<span class="s">&quot;B&quot;</span>].default_value = min(<span class="n">1.0</span>, roughness + <span class="n">0.18</span>)
+        rfac = rmix.inputs.get(<span class="s">&quot;Factor&quot;</span>) <span class="k">or</span> rmix.inputs.get(<span class="s">&quot;Fac&quot;</span>)
+        nt.links.new(tex.outputs[<span class="s">&quot;Fac&quot;</span>], rfac)
+        nt.links.new(rmix.outputs[<span class="s">&quot;Result&quot;</span>], bsdf.inputs[<span class="s">&quot;Roughness&quot;</span>])
     <span class="k">return</span> mat
 
 
+<span class="k">def</span> _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 slat and armrest is its own shell, so each gets one tone and
+    grain along its own long axis. Iron shells get a tone too; the iron
+    shader ignores it.
+    &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> shells(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> _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 slat (``GrainDir``), tone per slat (``PlankTone``).&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> bench_materials():
+    <span class="s">&quot;&quot;&quot;(wood, metal): shared by the check, the render and inspection.
+
+    The first build was one flat brown on every slat and satin iron
+    (metallic 1.0, roughness 0.32) that read as chrome.
+    &quot;&quot;&quot;</span>
+    wood = wood_material(<span class="s">&quot;BenchWood&quot;</span>)
+    metal = principled(
+        <span class="s">&quot;BenchIron&quot;</span>, (<span class="n">0.040</span>, <span class="n">0.042</span>, <span class="n">0.045</span>, <span class="n">1.0</span>), <span class="n">0.60</span>, <span class="n">0.55</span>,
+        noise_scale=<span class="n">18.0</span>, wear=(<span class="n">0.11</span>, <span class="n">0.055</span>, <span class="n">0.028</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)
@@ -1001,27 +1216,75 @@ <h2>Source</h2>
         bm.free()
 
 
+<span class="k">def</span> shell_bite(me, ga, gb):
+    <span class="s">&quot;&quot;&quot;Deepest vertex of shell ``ga`` inside closed shell ``gb`` (m); negative if none is.&quot;&quot;&quot;</span>
+    bm_b = bmesh.new()
+    <span class="k">try</span>:
+        bm_b.from_mesh(me)
+        keep_b = set(gb)
+        drop_b = [f <span class="k">for</span> f <span class="k">in</span> bm_b.faces <span class="k">if</span> <span class="k">not</span> all(v.index <span class="k">in</span> keep_b <span class="k">for</span> v <span class="k">in</span> f.verts)]
+        <span class="k">if</span> drop_b:
+            bmesh.ops.delete(bm_b, geom=drop_b, context=<span class="s">&quot;FACES&quot;</span>)
+        <span class="k">if</span> <span class="k">not</span> bm_b.faces:
+            <span class="k">return</span> -<span class="n">1e9</span>
+        bmesh.ops.recalc_face_normals(bm_b, faces=list(bm_b.faces))
+        tree = BVHTree.FromBMesh(bm_b)
+        best = -<span class="n">1e9</span>
+        <span class="k">for</span> i <span class="k">in</span> ga:
+            co = me.vertices[i].co
+            loc, nrm, _idx, dist = tree.find_nearest(co)
+            <span class="k">if</span> loc <span class="k">is</span> <span class="k">None</span>:
+                <span class="k">continue</span>
+            depth = dist <span class="k">if</span> (co - loc).dot(nrm) &lt; <span class="n">0.0</span> <span class="k">else</span> -dist
+            best = max(best, depth)
+        <span class="k">return</span> best
+    <span class="k">finally</span>:
+        bm_b.free()
+
+
 <span class="k">def</span> joint_audit(me):
     groups = shells(me)
+    owner = {}
+    <span class="k">for</span> gi, g <span class="k">in</span> enumerate(groups):
+        <span class="k">for</span> i <span class="k">in</span> g:
+            owner[i] = gi
+    rail_z = SEAT_Z - IRON_T * <span class="n">0.35</span> + BAR_R
+    arm_z = ARM_Z + BAR_R
     posts = []
     stretchers = []
     slats = []
-    <span class="k">for</span> g <span class="k">in</span> groups:
+    seat_slats = []
+    back_slats = []
+    side_rails = []
+    arm_bars = []
+    armrests = []
+    <span class="k">for</span> gi, g <span class="k">in</span> enumerate(groups):
         a = shell_aabb(me, g)
         dx, dy, dz = a[<span class="n">3</span>] - a[<span class="n">0</span>], a[<span class="n">4</span>] - a[<span class="n">1</span>], a[<span class="n">5</span>] - a[<span class="n">2</span>]
+        cz = <span class="n">0.5</span> * (a[<span class="n">2</span>] + a[<span class="n">5</span>])
         mat = mat_of(me, g)
-        <span class="k">if</span> mat == METAL_IDX <span class="k">and</span> dz &gt; <span class="n">0.28</span> <span class="k">and</span> dx &lt; <span class="n">0.08</span> <span class="k">and</span> dy &lt; <span class="n">0.08</span>:
-            posts.append((g, a))
-        <span class="k">if</span> mat == METAL_IDX <span class="k">and</span> abs(<span class="n">0.5</span> * (a[<span class="n">2</span>] + a[<span class="n">5</span>]) - STRETCHER_Z) &lt; <span class="n">0.05</span> <span class="k">and</span> max(dx, dy) &gt; <span class="n">0.25</span>:
+        <span class="c"># A leg is one bar from toe to arm (front) or back top (rear); it is</span>
+        <span class="c"># thin across the bench and tall, whatever its depth in plan.</span>
+        <span class="k">if</span> mat == METAL_IDX <span class="k">and</span> dz &gt; <span class="n">0.28</span> <span class="k">and</span> dx &lt; <span class="n">0.08</span>:
+            posts.append((g, a, gi))
+        <span class="k">if</span> mat == METAL_IDX <span class="k">and</span> abs(cz - STRETCHER_Z) &lt; <span class="n">0.05</span> <span class="k">and</span> max(dx, dy) &gt; <span class="n">0.25</span>:
             stretchers.append((g, a))
+        <span class="k">if</span> mat == METAL_IDX <span class="k">and</span> dx &lt; <span class="n">0.08</span> <span class="k">and</span> dy &gt; <span class="n">0.30</span> <span class="k">and</span> dz &lt; <span class="n">0.05</span>:
+            <span class="k">if</span> abs(cz - rail_z) &lt; <span class="n">0.02</span>:
+                side_rails.append((g, a))
+            <span class="k">elif</span> abs(cz - arm_z) &lt; <span class="n">0.02</span>:
+                arm_bars.append((g, a))
         <span class="k">if</span> mat == WOOD_IDX <span class="k">and</span> dz &lt; <span class="n">0.08</span> <span class="k">and</span> dx &gt; SEAT_SPAN * <span class="n">0.4</span>:
             slats.append((g, a))
+            (seat_slats <span class="k">if</span> cz &lt; SEAT_Z + <span class="n">0.10</span> <span class="k">else</span> back_slats).append((g, a))
+        <span class="k">if</span> mat == WOOD_IDX <span class="k">and</span> dx &lt; <span class="n">0.08</span> <span class="k">and</span> dy &gt; <span class="n">0.20</span>:
+            armrests.append((g, a))
     metal_verts = []
     <span class="k">for</span> poly <span class="k">in</span> me.polygons:
         <span class="k">if</span> poly.material_index != METAL_IDX:
             <span class="k">continue</span>
         <span class="k">for</span> i <span class="k">in</span> poly.vertices:
-            metal_verts.append(me.vertices[i].co)
+            metal_verts.append(i)
     stations = (
         (HX, HY + SCROLL_R, <span class="n">0.0</span>),
         (HX, -HY - SCROLL_R, <span class="n">0.0</span>),
@@ -1030,26 +1293,70 @@ <h2>Source</h2>
     )
     toes = <span class="n">0</span>
     toe_z = <span class="n">99.0</span>
+    leg_ids = {gi <span class="k">for</span> _g, _a, gi <span class="k">in</span> posts}
+    tall = {gi <span class="k">for</span> _g, a, gi <span class="k">in</span> posts <span class="k">if</span> a[<span class="n">5</span>] &gt;= SEAT_Z}
+    continuous = set()
     <span class="k">for</span> sx, sy, sz <span class="k">in</span> stations:
         nearby = []
-        <span class="k">for</span> co <span class="k">in</span> metal_verts:
+        <span class="k">for</span> i <span class="k">in</span> metal_verts:
+            co = me.vertices[i].co
             d = ((co.x - sx) ** <span class="n">2</span> + (co.y - sy) ** <span class="n">2</span>) ** <span class="n">0.5</span>
             <span class="k">if</span> d &lt; SCROLL_R * <span class="n">0.55</span>:
-                nearby.append(co)
+                nearby.append(i)
         <span class="k">if</span> nearby:
             toes += <span class="n">1</span>
-            toe_z = min(toe_z, min(c.z <span class="k">for</span> c <span class="k">in</span> nearby))
+            toe_z = min(toe_z, min(me.vertices[i].co.z <span class="k">for</span> i <span class="k">in</span> nearby))
+            <span class="c"># The toe&#x27;s own shell must be a leg that reaches the seat: a</span>
+            <span class="c"># foot that is a separate arc under its post fails here.</span>
+            low = min(nearby, key=<span class="k">lambda</span> i: me.vertices[i].co.z)
+            gi = owner[low]
+            <span class="k">if</span> gi <span class="k">in</span> leg_ids <span class="k">and</span> gi <span class="k">in</span> tall:
+                continuous.add(gi)
     st_gap = <span class="n">99.0</span>
     <span class="k">if</span> stretchers <span class="k">and</span> posts:
         st_gap = min(shell_bvh_gap(me, s[<span class="n">0</span>], p[<span class="n">0</span>]) <span class="k">for</span> s <span class="k">in</span> stretchers <span class="k">for</span> p <span class="k">in</span> posts)
     slat_gap = <span class="n">99.0</span>
-    rails = [p <span class="k">for</span> p <span class="k">in</span> posts]
-    <span class="k">if</span> slats <span class="k">and</span> rails:
-        slat_gap = min(shell_bvh_gap(me, s[<span class="n">0</span>], p[<span class="n">0</span>]) <span class="k">for</span> s <span class="k">in</span> slats <span class="k">for</span> p <span class="k">in</span> rails)
+    <span class="k">if</span> slats <span class="k">and</span> posts:
+        slat_gap = min(shell_bvh_gap(me, s[<span class="n">0</span>], p[<span class="n">0</span>]) <span class="k">for</span> s <span class="k">in</span> slats <span class="k">for</span> p <span class="k">in</span> posts)
     seat_x = <span class="n">0.0</span>
     <span class="k">if</span> slats:
         xs = [v <span class="k">for</span> _g, a <span class="k">in</span> slats <span class="k">for</span> v <span class="k">in</span> (a[<span class="n">0</span>], a[<span class="n">3</span>])]
         seat_x = max(xs) - min(xs)
+
+    <span class="c"># Bearing bites: every seat slat is carried by both side rails, every</span>
+    <span class="c"># back slat by both reclined uprights, every armrest by its front leg</span>
+    <span class="c"># and its arm bar. Deepest carrier vertex inside the carried shell.</span>
+    rear = [(g, a) <span class="k">for</span> g, a, _gi <span class="k">in</span> posts <span class="k">if</span> a[<span class="n">5</span>] &gt; ARM_Z + <span class="n">0.10</span>]
+    front = [(g, a) <span class="k">for</span> g, a, _gi <span class="k">in</span> posts <span class="k">if</span> a[<span class="n">5</span>] &lt;= ARM_Z + <span class="n">0.10</span>]
+    bites = []
+    <span class="c"># Overlap depth either way round: a rail has vertices only at its ends,</span>
+    <span class="c"># so under a mid-span slat it is the slat&#x27;s corner that sits in the rail.</span>
+    <span class="k">def</span> overlap(ga, gb):
+        <span class="k">return</span> max(shell_bite(me, ga, gb), shell_bite(me, gb, ga))
+
+    <span class="k">for</span> s, _a <span class="k">in</span> seat_slats:
+        <span class="k">for</span> rl, _b <span class="k">in</span> side_rails:
+            bites.append((<span class="s">&quot;seat&quot;</span>, overlap(rl, s)))
+    <span class="k">for</span> s, _a <span class="k">in</span> back_slats:
+        <span class="k">for</span> up, _b <span class="k">in</span> rear:
+            bites.append((<span class="s">&quot;back&quot;</span>, overlap(up, s)))
+    <span class="k">for</span> s, a <span class="k">in</span> armrests:
+        side = <span class="n">0.5</span> * (a[<span class="n">0</span>] + a[<span class="n">3</span>])
+        <span class="k">for</span> host, b <span class="k">in</span> front + arm_bars:
+            <span class="k">if</span> abs(<span class="n">0.5</span> * (b[<span class="n">0</span>] + b[<span class="n">3</span>]) - side) &lt; <span class="n">0.05</span>:
+                bites.append((<span class="s">&quot;arm&quot;</span>, overlap(host, s)))
+    bite_min = min((b <span class="k">for</span> _k, b <span class="k">in</span> bites), default=-<span class="n">1.0</span>)
+    bite_kind = min(bites, key=<span class="k">lambda</span> kb: kb[<span class="n">1</span>])[<span class="n">0</span>] <span class="k">if</span> bites <span class="k">else</span> <span class="s">&quot;none&quot;</span>
+
+    <span class="c"># Recline of each rear upright: centroids of a low and a high slab.</span>
+    recl = []
+    <span class="k">for</span> g, a <span class="k">in</span> rear:
+        lo_s = [me.vertices[i].co <span class="k">for</span> i <span class="k">in</span> g <span class="k">if</span> SEAT_Z + <span class="n">0.16</span> &lt;= me.vertices[i].co.z &lt;= SEAT_Z + <span class="n">0.26</span>]
+        hi_s = [me.vertices[i].co <span class="k">for</span> i <span class="k">in</span> g <span class="k">if</span> a[<span class="n">5</span>] - <span class="n">0.16</span> &lt;= me.vertices[i].co.z &lt;= a[<span class="n">5</span>] - <span class="n">0.06</span>]
+        <span class="k">if</span> lo_s <span class="k">and</span> hi_s:
+            c0 = sum(lo_s, Vector()) / len(lo_s)
+            c1 = sum(hi_s, Vector()) / len(hi_s)
+            recl.append(math.degrees(math.atan2(abs(c1.y - c0.y), c1.z - c0.z)))
     <span class="k">return</span> {
         <span class="s">&quot;toes&quot;</span>: toes,
         <span class="s">&quot;toe_z&quot;</span>: toe_z,
@@ -1059,6 +1366,16 @@ <h2>Source</h2>
         <span class="s">&quot;slat_gap&quot;</span>: slat_gap,
         <span class="s">&quot;seat_x&quot;</span>: seat_x,
         <span class="s">&quot;slats&quot;</span>: len(slats),
+        <span class="s">&quot;legs_whole&quot;</span>: len(continuous),
+        <span class="s">&quot;seat_slats&quot;</span>: len(seat_slats),
+        <span class="s">&quot;back_slats&quot;</span>: len(back_slats),
+        <span class="s">&quot;side_rails&quot;</span>: len(side_rails),
+        <span class="s">&quot;arm_bars&quot;</span>: len(arm_bars),
+        <span class="s">&quot;armrests&quot;</span>: len(armrests),
+        <span class="s">&quot;bites&quot;</span>: len(bites),
+        <span class="s">&quot;bite_min&quot;</span>: bite_min,
+        <span class="s">&quot;bite_kind&quot;</span>: bite_kind,
+        <span class="s">&quot;recline&quot;</span>: recl,
     }
 
 
@@ -1122,6 +1439,9 @@ <h2>Source</h2>
     gap_slats=<span class="k">False</span>,
     short_feet=<span class="k">False</span>,
     narrow_seat=<span class="k">False</span>,
+    float_slats=<span class="k">False</span>,
+    split_feet=<span class="k">False</span>,
+    upright_back=<span class="k">False</span>,
 ):
     bpy.ops.wm.read_factory_settings(use_empty=<span class="k">True</span>)
     kw = dict(
@@ -1129,17 +1449,15 @@ <h2>Source</h2>
         gap_slats=gap_slats,
         short_feet=short_feet,
         narrow_seat=narrow_seat,
+        float_slats=float_slats,
+        split_feet=split_feet,
+        upright_back=upright_back,
     )
     low = build_bench_mesh(<span class="s">&quot;BenchLow&quot;</span>, bevel_offset=<span class="n">0.004</span>, bevel_segments=<span class="n">2</span>, **kw)
     high = build_bench_mesh(<span class="s">&quot;BenchHigh&quot;</span>, bevel_offset=<span class="n">0.004</span>, bevel_segments=<span class="n">4</span>, **kw)
-    wood = principled(
-        <span class="s">&quot;BenchWood&quot;</span>, (<span class="n">0.40</span>, <span class="n">0.20</span>, <span class="n">0.07</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.58</span>,
-        noise_scale=<span class="n">18.0</span>, wear=(<span class="n">0.28</span>, <span class="n">0.14</span>, <span class="n">0.05</span>, <span class="n">1.0</span>),
-    )
-    metal = principled(
-        <span class="s">&quot;BenchIron&quot;</span>, (<span class="n">0.09</span>, <span class="n">0.095</span>, <span class="n">0.11</span>, <span class="n">1.0</span>), <span class="n">1.0</span>, <span class="n">0.32</span>,
-        noise_scale=<span class="n">22.0</span>, wear=(<span class="n">0.16</span>, <span class="n">0.14</span>, <span class="n">0.10</span>, <span class="n">1.0</span>),
-    )
+    paint_planks(low.data)
+    paint_planks(high.data)
+    wood, metal = bench_materials()
     assign_slots(low, wood, metal)
     assign_slots(high, wood, metal)
 
@@ -1195,6 +1513,9 @@ <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="c"># Measured; do not leave a .glb per run in the temp directory.</span>
+        os.remove(export_path)
 
     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(
@@ -1227,6 +1548,14 @@ <h2>Source</h2>
         <span class="s">f&quot;</span><span class="s">st_gap=</span>{jnt[<span class="s">&#x27;st_gap&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> slat_gap=</span>{jnt[<span class="s">&#x27;slat_gap&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> </span><span class="s">&quot;</span>
         <span class="s">f&quot;</span><span class="s">seat_x=</span>{jnt[<span class="s">&#x27;seat_x&#x27;</span>]:<span class="s">.4f</span>}<span class="s"> slats=</span>{jnt[<span class="s">&#x27;slats&#x27;</span>]}<span class="s">&quot;</span>
     )
+    recl = jnt[<span class="s">&quot;recline&quot;</span>]
+    print(
+        <span class="s">f&quot;</span><span class="s">measured legs_whole=</span>{jnt[<span class="s">&#x27;legs_whole&#x27;</span>]}<span class="s"> seat_slats=</span>{jnt[<span class="s">&#x27;seat_slats&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">back_slats=</span>{jnt[<span class="s">&#x27;back_slats&#x27;</span>]}<span class="s"> side_rails=</span>{jnt[<span class="s">&#x27;side_rails&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">arm_bars=</span>{jnt[<span class="s">&#x27;arm_bars&#x27;</span>]}<span class="s"> armrests=</span>{jnt[<span class="s">&#x27;armrests&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">bites=</span>{jnt[<span class="s">&#x27;bites&#x27;</span>]}<span class="s"> bite_min=</span>{jnt[<span class="s">&#x27;bite_min&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> (</span>{jnt[<span class="s">&#x27;bite_kind&#x27;</span>]}<span class="s">) </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">recline=</span>{[round(v, <span class="n">2</span>) <span class="k">for</span> v <span class="k">in</span> recl]}<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(
@@ -1321,6 +1650,29 @@ <h2>Source</h2>
             <span class="s">f&quot;</span><span class="s">slat gap </span>{jnt[<span class="s">&#x27;slat_gap&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> slats=</span>{jnt[<span class="s">&#x27;slats&#x27;</span>]}<span class="s">&quot;</span>,
             <span class="n">18</span>,
         ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+    want_bites = <span class="n">2</span> * N_SEAT + <span class="n">2</span> * N_BACK + <span class="n">4</span>
+    <span class="k">if</span> (
+        jnt[<span class="s">&quot;seat_slats&quot;</span>] != N_SEAT <span class="k">or</span> jnt[<span class="s">&quot;back_slats&quot;</span>] != N_BACK
+        <span class="k">or</span> jnt[<span class="s">&quot;side_rails&quot;</span>] != <span class="n">2</span> <span class="k">or</span> jnt[<span class="s">&quot;arm_bars&quot;</span>] != <span class="n">2</span> <span class="k">or</span> jnt[<span class="s">&quot;armrests&quot;</span>] != <span class="n">2</span>
+        <span class="k">or</span> jnt[<span class="s">&quot;bites&quot;</span>] != want_bites <span class="k">or</span> jnt[<span class="s">&quot;bite_min&quot;</span>] &lt; BITE_MIN
+    ):
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">bearing bite </span>{jnt[<span class="s">&#x27;bite_min&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> (</span>{jnt[<span class="s">&#x27;bite_kind&#x27;</span>]}<span class="s">) &lt; </span>{BITE_MIN}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">f&quot;</span><span class="s">or members seat=</span>{jnt[<span class="s">&#x27;seat_slats&#x27;</span>]}<span class="s"> back=</span>{jnt[<span class="s">&#x27;back_slats&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">f&quot;</span><span class="s">rails=</span>{jnt[<span class="s">&#x27;side_rails&#x27;</span>]}<span class="s"> bars=</span>{jnt[<span class="s">&#x27;arm_bars&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">f&quot;</span><span class="s">arms=</span>{jnt[<span class="s">&#x27;armrests&#x27;</span>]}<span class="s"> bites=</span>{jnt[<span class="s">&#x27;bites&#x27;</span>]}<span class="s">/</span>{want_bites}<span class="s">&quot;</span>,
+            <span class="n">20</span>,
+        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+    <span class="k">if</span> jnt[<span class="s">&quot;legs_whole&quot;</span>] != LEG_COUNT:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">legs bent in one piece toe to seat </span>{jnt[<span class="s">&#x27;legs_whole&#x27;</span>]}<span class="s"> != </span>{LEG_COUNT}<span class="s">&quot;</span>,
+            <span class="n">21</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> len(recl) != <span class="n">2</span> <span class="k">or</span> <span class="k">not</span> all(RECLINE_MIN_DEG &lt;= v &lt;= RECLINE_MAX_DEG <span class="k">for</span> v <span class="k">in</span> recl):
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">back recline </span>{recl}<span class="s"> not in [</span>{RECLINE_MIN_DEG}<span class="s">, </span>{RECLINE_MAX_DEG}<span class="s">] deg</span><span class="s">&quot;</span>,
+            <span class="n">19</span>,
+        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
     <span class="k">return</span> <span class="n">0</span>, low, high, wood, tex, collider
 
 
@@ -1341,13 +1693,13 @@ <h2>Source</h2>
             ob.hide_render = <span class="k">True</span>
             ob.hide_viewport = <span class="k">True</span>
 
+    <span class="c"># Level on the floor: an X tilt sinks the front toes and lifts the back.</span>
     low.rotation_euler.z = math.radians(-<span class="n">14.0</span>)
-    low.rotation_euler.x = math.radians(<span class="n">2.0</span>)
 
     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()
@@ -1441,6 +1793,9 @@ <h2>Source</h2>
     p.add_argument(<span class="s">&quot;--float-stretcher&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
     p.add_argument(<span class="s">&quot;--gap-slats&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
     p.add_argument(<span class="s">&quot;--narrow-seat&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--float-slats&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--split-feet&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--upright-back&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
     args = p.parse_args(argv)
 
     code, low, _high, wood, tex, _col = check(
@@ -1451,6 +1806,9 @@ <h2>Source</h2>
         gap_slats=args.gap_slats,
         short_feet=args.short_feet,
         narrow_seat=args.narrow_seat,
+        float_slats=args.float_slats,
+        split_feet=args.split_feet,
+        upright_back=args.upright_back,
     )
     <span class="k">if</span> code:
         <span class="k">return</span> code
@@ -1475,7 +1833,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/park-bench-hero.webp" alt="A park bench of wooden slats on a wrought-iron frame with scrolled feet and armrests." />
+    <img src="../assets/park-bench-hero.webp" alt="A park bench of grained wooden slats with a reclined back, on a dark wrought-iron frame whose round-bar legs curl into scrolled feet, with armrests on curved brackets." />
   </dialog>
   <footer>
     <div class="statusbar">
diff --git a/docs/gallery/soccer-ball-goldberg/index.html b/docs/gallery/soccer-ball-goldberg/index.html
index 347ddc4d..f487d641 100644
--- a/docs/gallery/soccer-ball-goldberg/index.html
+++ b/docs/gallery/soccer-ball-goldberg/index.html
@@ -16,13 +16,13 @@
   <meta property="og:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/soccer-ball-goldberg-hero.webp" />
   <meta property="og:image:width" content="1280" />
   <meta property="og:image:height" content="720" />
-  <meta property="og:image:alt" content="A white soccer ball with black pentagon panels, built as a smoothed Goldberg polyhedron." />
+  <meta property="og:image:alt" content="A round white soccer ball with black pentagon panels and dark stitched seams outlining every white hexagon, built as a smoothed Goldberg polyhedron." />
   <meta property="og:site_name" content="Blender Developer Tools" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="soccer-ball-goldberg — Examples — Blender Developer Tools" />
   <meta name="twitter:description" content="A soccer ball as a Goldberg polyhedron: a bmesh icosphere truncated at 1/3 per edge, faces ordered by link-topology walks, panels bound by face vertex count." />
   <meta name="twitter:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/soccer-ball-goldberg-hero.webp" />
-  <meta name="twitter:image:alt" content="A white soccer ball with black pentagon panels, built as a smoothed Goldberg polyhedron." />
+  <meta name="twitter:image:alt" content="A round white soccer ball with black pentagon panels and dark stitched seams outlining every white hexagon, built as a smoothed Goldberg polyhedron." />
   <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>soccer-ball-goldberg</h1>
     <p>A soccer ball as a Goldberg polyhedron: a bmesh icosphere truncated at 1/3 per edge, faces ordered by link-topology walks, panels bound by face vertex count.</p>
   </header>
   <main id="main">
-    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: A white soccer ball with black pentagon panels, built as a smoothed Goldberg polyhedron.">
-      <img src="../assets/soccer-ball-goldberg-hero.webp" alt="A white soccer ball with black pentagon panels, built as a smoothed Goldberg polyhedron." width="1280" height="720" />
+    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: A round white soccer ball with black pentagon panels and dark stitched seams outlining every white hexagon, built as a smoothed Goldberg polyhedron.">
+      <img src="../assets/soccer-ball-goldberg-hero.webp" alt="A round white soccer ball with black pentagon panels and dark stitched seams outlining every white hexagon, built as a smoothed Goldberg polyhedron." 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> Goldberg invariants are closed forms — counts, degree 3, uniform edges, planar faces, one circumsphere — and panels bind by vertex count, never enumeration order.</div>
@@ -284,7 +284,10 @@ <h1>soccer-ball-goldberg</h1>
 <ul><li><strong>Counts and characteristic.</strong> V=60, E=90, F=32, Euler <code>V−E+F==2</code> — the sphere topology. Catches a leaked or dropped face/edge/vertex (probe: one face deleted → exit 3, topology <code>(60, 90, 31)</code>).</li><li><strong>Face census.</strong> Exactly 12 five-sided and 20 six-sided faces (exit 5).</li><li><strong>Uniform degree 3.</strong> Every vertex touches exactly three edges, and every edge borders exactly two faces — the Goldberg dual property, watertight (exit 6/7).</li><li><strong>Edge uniformity.</strong> Max deviation from the mean length, measured <strong>6.471e-06</strong> against tol 3.0e-05 (exit 8). Catches a vertex dragged off the lattice (probe: one vertex shifted 0.05 → exit 8, deviation <strong>4.726e-02</strong>, three orders of magnitude over tolerance).</li><li><strong>Face planarity.</strong> Worst vertex-to-plane distance <strong>1.888e-06</strong> against the same tolerance, measured against an independent Newell normal — not Blender&#x27;s polygon normal (exit 9).</li><li><strong>Circumsphere.</strong> Centroid on the origin (<code>0.000e+00</code>, tol 1e-6) and every vertex equidistant from it: max deviation <strong>8.956e-06</strong> (exit 10/11).</li><li><strong>Panel binding by class.</strong> Exactly two materials; every 5-gon carries slot 1 (black), every 6-gon slot 0 (white). The builder assigns by <code>len(poly.vertices)</code>, and the check re-derives the expectation the same way — so an enumeration-order shortcut fails (probe: last-12-faces-black → exit 13, <strong>24 misbound faces</strong>; inverted classes → exit 13, <strong>32 misbound</strong>). Enumeration order coinciding with class order is a construction artifact, not a contract — the check exists for the cases where it doesn&#x27;t.</li></ul>
 <p><strong>Tolerance basis:</strong> mesh coordinates are float32 and <code>create_icosphere</code>&#x27;s own trig lands the invariants at a deterministic ~9e-6 noise floor (measured values are byte-identical on 4.5.11 and 5.1.2). The 3e-5 gates sit ~3x above that floor; any genuine contract break is orders of magnitude larger.</p>
 <p><strong>Version witness:</strong> check output is byte-identical on Blender 4.5.11 LTS and 5.1.2 — same counts, same deviations. One authoring hazard surfaced and is noted in the code: <code>Object.to_mesh_clear()</code> takes <strong>no argument</strong> on current Blender (passing the mesh raises TypeError) — see <a href="https://github.com/TMHSDigital/Blender-Developer-Tools/tree/main/skills/depsgraph-and-evaluated-data/SKILL.md"><code>depsgraph-and-evaluated-data</code></a>.</p>
-<p>The render is the proof: the faceted Goldberg cage is smoothed by an <strong>unapplied</strong> Subsurf modifier (panel materials carry through Catmull-Clark per face class), and the ball is grounded by its depsgraph-evaluated lowest vertex — center-at-circumradius floats the ball, because the smoothed surface sinks toward the face inradii. Invert the panel binding and the still inverts with it: white pentagons on a black ball, wrong on sight.</p>
+<p>The render is the proof: the faceted Goldberg cage is smoothed by an <strong>unapplied</strong> Subsurf modifier (panel materials carry through Catmull-Clark per face class), and the ball is grounded by its depsgraph-evaluated lowest vertex. Invert the panel binding and the still inverts with it: white pentagons on a black ball, wrong on sight.</p>
+<h3>Staging (render path only)</h3>
+<p>None of this touches the checked mesh, its binding, or any check.</p>
+<ul><li><strong>Round, not lumpy.</strong> Catmull-Clark on a 60-vertex cage leaves flats over every hexagon; the clay pass read as a lumpy stone. An unapplied Cast modifier after the Subsurf pulls the surface onto a sphere of the cage&#x27;s own circumradius.</li><li><strong>Every panel visible.</strong> The white hexagons used to merge into one white shell, so the still showed 12 of the 32 panels the check counts. A render-only copy of the mesh, turned into a wire, subdivided and cast onto a sphere 2 mm proud of the ball, draws every panel boundary as a stitched seam. It is parented to the ball and bound to the dark slot on the copy only.</li><li><strong>Framing gate.</strong> The render path calls <a href="https://github.com/TMHSDigital/Blender-Developer-Tools/tree/main/examples/gallery_framing.py"><code>gallery_framing.check_framing</code></a> before writing the still. The helper returns 10, which this example already spends on the centroid check, so the call site maps a violation to <strong>14</strong>. The larger, rounder ball touched the top edge at the old 55 mm lens; the lens is now 50 mm.</li></ul>
 <h2>Run</h2>
 <pre><code># Cheap correctness check (no render) — the CI check:
 blender --background --python soccer_ball_goldberg.py --
@@ -297,7 +300,7 @@ <h2>Run</h2>
 blender --background --python soccer_ball_goldberg.py -- --output ball.png --engine cycles</code></pre>
 <h2>Exit codes</h2>
 <p>Per-script sequential checks. <code>9</code> is a valid check code; there is no rule against it.</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>Topology ≠ 60/90/32</td></tr><tr><td>4</td><td>Euler characteristic ≠ 2</td></tr><tr><td>5</td><td>Face census ≠ 12 pentagons + 20 hexagons</td></tr><tr><td>6</td><td>Vertex degree not uniform 3; also <code>--output</code> produced no file</td></tr><tr><td>7</td><td>Non-manifold edges</td></tr><tr><td>8</td><td>Edge lengths not uniform</td></tr><tr><td>9</td><td>Face planarity off</td></tr><tr><td>10</td><td>Centroid off origin</td></tr><tr><td>11</td><td>Circumradius not uniform</td></tr><tr><td>12</td><td>Panel material count ≠ 2</td></tr><tr><td>13</td><td>Panel binding not by vertex count (<code>--invert-bind</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>Topology ≠ 60/90/32</td></tr><tr><td>4</td><td>Euler characteristic ≠ 2</td></tr><tr><td>5</td><td>Face census ≠ 12 pentagons + 20 hexagons</td></tr><tr><td>6</td><td>Vertex degree not uniform 3; also <code>--output</code> produced no file</td></tr><tr><td>7</td><td>Non-manifold edges</td></tr><tr><td>8</td><td>Edge lengths not uniform</td></tr><tr><td>9</td><td>Face planarity off</td></tr><tr><td>10</td><td>Centroid off origin</td></tr><tr><td>11</td><td>Circumradius not uniform</td></tr><tr><td>12</td><td>Panel material count ≠ 2</td></tr><tr><td>13</td><td>Panel binding not by vertex count (<code>--invert-bind</code> lands here)</td></tr><tr><td>14</td><td>Framing gate (<code>--output</code> path only; <code>gallery_framing</code> returns 10, remapped)</td></tr></tbody></table></div>
 <p>The <code>blender-smoke</code> workflow runs the check on Blender 5.2 LTS and 4.5 LTS (5.1 on the weekly cron, the <code>needs-5.1</code> PR label, or manual dispatch). Smoke does not pass <code>--output</code> or <code>--invert-bind</code>.</p>
     </section>
     <section class="detail-section src">
@@ -326,6 +329,11 @@ <h2>Source</h2>
 &quot;&quot;&quot;</span>
 <span class="k">import</span> bpy, bmesh, sys, os, math, argparse
 
+<span class="c"># Shared Layer 1 framing measurement (render path only) — see gallery_framing.py</span>
+sys.path.insert(<span class="n">0</span>, os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir))
+sys.dont_write_bytecode = <span class="k">True</span>  <span class="c"># keep examples/__pycache__ out of the repo tree</span>
+<span class="k">import</span> gallery_framing
+
 <span class="c"># truncation parameter: cutting each icosahedron edge at 1/3 makes every new</span>
 <span class="c"># edge the same length (a/3), which is what makes the result an Archimedean</span>
 <span class="c"># solid with a circumsphere at all</span>
@@ -340,6 +348,9 @@ <h2>Source</h2>
 TOL_PLANAR = <span class="n">3.0e-5</span>         <span class="c"># face planarity (max vertex-to-plane distance)</span>
 TOL_RADIUS = <span class="n">3.0e-5</span>         <span class="c"># circumsphere uniformity</span>
 TOL_CENTER = <span class="n">1.0e-6</span>         <span class="c"># centroid at origin</span>
+SEAM_WIDTH = <span class="n">0.018</span>          <span class="c"># render only: stitched seam width on the ball</span>
+SEAM_LIFT = <span class="n">0.002</span>           <span class="c"># render only: seam sits this far proud of the ball</span>
+FRAMING_EXIT = <span class="n">14</span>           <span class="c"># render only: gallery_framing returns 10, taken here</span>
 
 <span class="c"># closed forms for a truncated icosahedron (Goldberg polyhedron GP(1,1))</span>
 EXPECT_V, EXPECT_E, EXPECT_F = <span class="n">60</span>, <span class="n">90</span>, <span class="n">32</span>
@@ -600,16 +611,48 @@ <h2>Source</h2>
     me = obj.data
     _panel_materials(obj)
 
-    <span class="c"># the check reads the base mesh; the still adds an UNAPPLIED Subsurf so</span>
-    <span class="c"># the faceted Goldberg cage reads as an inflated ball. Panel materials</span>
-    <span class="c"># carry through Catmull-Clark per face class, so a misbound panel would</span>
+    <span class="c"># the check reads the base mesh; the still adds UNAPPLIED modifiers so</span>
+    <span class="c"># the faceted Goldberg cage reads as a stitched ball. Panel materials</span>
+    <span class="c"># carry through every stage per face class, so a misbound panel would</span>
     <span class="c"># still show in the image.</span>
     <span class="k">for</span> poly <span class="k">in</span> me.polygons:
         poly.use_smooth = <span class="k">True</span>
     sub = obj.modifiers.new(<span class="s">&quot;Inflate&quot;</span>, <span class="s">&#x27;SUBSURF&#x27;</span>)
     sub.subdivision_type = <span class="s">&#x27;CATMULL_CLARK&#x27;</span>
-    sub.levels = <span class="n">2</span>
-    sub.render_levels = <span class="n">2</span>
+    sub.levels = <span class="n">3</span>
+    sub.render_levels = <span class="n">3</span>
+    <span class="c"># Catmull-Clark on a 60-vertex cage leaves flats over the hexagons (the</span>
+    <span class="c"># clay pass reads as a lumpy stone); Cast pulls the surface onto a sphere</span>
+    <span class="c"># of the cage&#x27;s own circumradius</span>
+    cast = obj.modifiers.new(<span class="s">&quot;Round&quot;</span>, <span class="s">&#x27;CAST&#x27;</span>)
+    cast.cast_type = <span class="s">&#x27;SPHERE&#x27;</span>
+    cast.factor = <span class="n">1.0</span>
+    cast.use_radius_as_size = <span class="k">True</span>
+    cast.radius = BALL_RADIUS
+
+    <span class="c"># stitched seams: without them the 20 white hexagons merge into one white</span>
+    <span class="c"># shell and only 12 of the 32 panels the check counts are visible. The</span>
+    <span class="c"># cage&#x27;s own edges, as a wire subdivided and cast onto a sphere just</span>
+    <span class="c"># proud of the ball, draw every panel boundary. A render-only copy of</span>
+    <span class="c"># the mesh, so the checked mesh and its binding are untouched.</span>
+    seam_me = me.copy()
+    <span class="k">for</span> poly <span class="k">in</span> seam_me.polygons:
+        poly.material_index = <span class="n">1</span>
+    seams = bpy.data.objects.new(<span class="s">&quot;Seams&quot;</span>, seam_me)
+    scene.collection.objects.link(seams)
+    seams.parent = obj
+    wire = seams.modifiers.new(<span class="s">&quot;Wire&quot;</span>, <span class="s">&#x27;WIREFRAME&#x27;</span>)
+    wire.thickness = SEAM_WIDTH
+    wire.use_replace = <span class="k">True</span>
+    fine = seams.modifiers.new(<span class="s">&quot;Follow&quot;</span>, <span class="s">&#x27;SUBSURF&#x27;</span>)
+    fine.subdivision_type = <span class="s">&#x27;SIMPLE&#x27;</span>
+    fine.levels = <span class="n">3</span>
+    fine.render_levels = <span class="n">3</span>
+    lay = seams.modifiers.new(<span class="s">&quot;Lay&quot;</span>, <span class="s">&#x27;CAST&#x27;</span>)
+    lay.cast_type = <span class="s">&#x27;SPHERE&#x27;</span>
+    lay.factor = <span class="n">1.0</span>
+    lay.use_radius_as_size = <span class="k">True</span>
+    lay.radius = BALL_RADIUS + SEAM_LIFT
 
     <span class="c"># a pentagon sits on the icosphere +Z pole; tip it toward the camera and</span>
     <span class="c"># spin for an asymmetric, match-worn panel layout</span>
@@ -670,7 +713,7 @@ <h2>Source</h2>
     light(<span class="s">&quot;Wedge&quot;</span>, (<span class="n">2.5</span>, <span class="n">5.5</span>, <span class="n">4.0</span>), <span class="n">380.0</span>, <span class="n">6.0</span>, (<span class="n">1.0</span>, <span class="n">0.76</span>, <span class="n">0.5</span>), (-<span class="n">68</span>, <span class="n">0</span>, <span class="n">190</span>))
 
     cam_data = bpy.data.cameras.new(<span class="s">&quot;Cam&quot;</span>)
-    cam_data.lens = <span class="n">55.0</span>
+    cam_data.lens = <span class="n">50.0</span>
     cam = bpy.data.objects.new(<span class="s">&quot;Cam&quot;</span>, cam_data)
     cam.location = (<span class="n">0.0</span>, -<span class="n">7.2</span>, <span class="n">3.8</span>)
     cam.rotation_euler = (math.radians(<span class="n">68</span>), <span class="n">0.0</span>, <span class="n">0.0</span>)
@@ -692,8 +735,14 @@ <h2>Source</h2>
     <span class="c"># AgX would wash the white leather toward grey and lift the stage</span>
     <span class="c"># (docs/VISUAL-STYLE.md); Standard is the house transform</span>
     scene.view_settings.view_transform = <span class="s">&#x27;Standard&#x27;</span>
+    <span class="k">if</span> gallery_framing.check_framing(scene, cam, hero=[obj], elements=[obj],
+                                     stage=[floor, wall]):
+        <span class="k">return</span> FRAMING_EXIT
     bpy.ops.render.render(write_still=<span class="k">True</span>)
-    <span class="k">return</span> os.path.exists(path) <span class="k">and</span> os.path.getsize(path) &gt; <span class="n">0</span>
+    <span class="k">if</span> <span class="k">not</span> (os.path.exists(path) <span class="k">and</span> os.path.getsize(path) &gt; <span class="n">0</span>):
+        print(<span class="s">&quot;ERROR: render produced no file&quot;</span>, file=sys.stderr)
+        <span class="k">return</span> <span class="n">6</span>
+    <span class="k">return</span> <span class="n">0</span>
 
 
 <span class="k">def</span> main():
@@ -712,9 +761,9 @@ <h2>Source</h2>
         <span class="k">return</span> code
 
     <span class="k">if</span> args.output:
-        <span class="k">if</span> <span class="k">not</span> render_still(obj, os.path.abspath(args.output), args.engine):
-            print(<span class="s">&quot;ERROR: render produced no file&quot;</span>, file=sys.stderr)
-            <span class="k">return</span> <span class="n">6</span>
+        rcode = render_still(obj, os.path.abspath(args.output), args.engine)
+        <span class="k">if</span> rcode:
+            <span class="k">return</span> rcode
         print(<span class="s">f&quot;</span><span class="s">rendered still </span>{args.output}<span class="s">&quot;</span>)
 
     print(<span class="s">&quot;soccer-ball-goldberg OK&quot;</span>)
@@ -731,7 +780,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/soccer-ball-goldberg-hero.webp" alt="A white soccer ball with black pentagon panels, built as a smoothed Goldberg polyhedron." />
+    <img src="../assets/soccer-ball-goldberg-hero.webp" alt="A round white soccer ball with black pentagon panels and dark stitched seams outlining every white hexagon, built as a smoothed Goldberg polyhedron." />
   </dialog>
   <footer>
     <div class="statusbar">
diff --git a/examples/gallery.json b/examples/gallery.json
index c6bd9ab5..42a18977 100644
--- a/examples/gallery.json
+++ b/examples/gallery.json
@@ -516,7 +516,7 @@
       "name": "soccer-ball-goldberg",
       "dir": "examples/soccer-ball-goldberg",
       "teaches": "A soccer ball as a Goldberg polyhedron: a bmesh icosphere truncated at 1/3 per edge, faces ordered by link-topology walks, panels bound by face vertex count.",
-      "alt": "A white soccer ball with black pentagon panels, built as a smoothed Goldberg polyhedron.",
+      "alt": "A round white soccer ball with black pentagon panels and dark stitched seams outlining every white hexagon, built as a smoothed Goldberg polyhedron.",
       "witnessesFix": "Goldberg invariants are closed forms — counts, degree 3, uniform edges, planar faces, one circumsphere — and panels bind by vertex count, never enumeration order.",
       "hero": "docs/gallery/assets/soccer-ball-goldberg-hero.webp",
       "preview": "examples/soccer-ball-goldberg/preview.webp",
diff --git a/examples/soccer-ball-goldberg/README.md b/examples/soccer-ball-goldberg/README.md
index e6b815b3..800255e3 100644
--- a/examples/soccer-ball-goldberg/README.md
+++ b/examples/soccer-ball-goldberg/README.md
@@ -58,9 +58,28 @@ Blender (passing the mesh raises TypeError) — see
 The render is the proof: the faceted Goldberg cage is smoothed by an
 **unapplied** Subsurf modifier (panel materials carry through Catmull-Clark
 per face class), and the ball is grounded by its depsgraph-evaluated lowest
-vertex — center-at-circumradius floats the ball, because the smoothed surface
-sinks toward the face inradii. Invert the panel binding and the still
-inverts with it: white pentagons on a black ball, wrong on sight.
+vertex. Invert the panel binding and the still inverts with it: white
+pentagons on a black ball, wrong on sight.
+
+### Staging (render path only)
+
+None of this touches the checked mesh, its binding, or any check.
+
+- **Round, not lumpy.** Catmull-Clark on a 60-vertex cage leaves flats over
+  every hexagon; the clay pass read as a lumpy stone. An unapplied Cast
+  modifier after the Subsurf pulls the surface onto a sphere of the cage's own
+  circumradius.
+- **Every panel visible.** The white hexagons used to merge into one white
+  shell, so the still showed 12 of the 32 panels the check counts. A
+  render-only copy of the mesh, turned into a wire, subdivided and cast onto a
+  sphere 2 mm proud of the ball, draws every panel boundary as a stitched seam.
+  It is parented to the ball and bound to the dark slot on the copy only.
+- **Framing gate.** The render path calls
+  [`gallery_framing.check_framing`](../gallery_framing.py) before writing the
+  still. The helper returns 10, which this example already spends on the
+  centroid check, so the call site maps a violation to **14**. The larger,
+  rounder ball touched the top edge at the old 55 mm lens; the lens is now
+  50 mm.
 
 ## Run
 
@@ -97,6 +116,7 @@ against it.
 | 11 | Circumradius not uniform |
 | 12 | Panel material count ≠ 2 |
 | 13 | Panel binding not by vertex count (`--invert-bind` lands here) |
+| 14 | Framing gate (`--output` path only; `gallery_framing` returns 10, remapped) |
 
 The `blender-smoke` workflow runs the check on Blender 5.2 LTS and 4.5 LTS
 (5.1 on the weekly cron, the `needs-5.1` PR label, or manual dispatch).
diff --git a/examples/soccer-ball-goldberg/preview.webp b/examples/soccer-ball-goldberg/preview.webp
index 7c880ceb..468602b2 100644
Binary files a/examples/soccer-ball-goldberg/preview.webp and b/examples/soccer-ball-goldberg/preview.webp differ
diff --git a/examples/soccer-ball-goldberg/soccer_ball_goldberg.py b/examples/soccer-ball-goldberg/soccer_ball_goldberg.py
index 16ad3e89..31b10fcf 100644
--- a/examples/soccer-ball-goldberg/soccer_ball_goldberg.py
+++ b/examples/soccer-ball-goldberg/soccer_ball_goldberg.py
@@ -18,6 +18,11 @@
 """
 import bpy, bmesh, sys, os, math, argparse
 
+# Shared Layer 1 framing measurement (render path only) — see gallery_framing.py
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir))
+sys.dont_write_bytecode = True  # keep examples/__pycache__ out of the repo tree
+import gallery_framing
+
 # truncation parameter: cutting each icosahedron edge at 1/3 makes every new
 # edge the same length (a/3), which is what makes the result an Archimedean
 # solid with a circumsphere at all
@@ -32,6 +37,9 @@
 TOL_PLANAR = 3.0e-5         # face planarity (max vertex-to-plane distance)
 TOL_RADIUS = 3.0e-5         # circumsphere uniformity
 TOL_CENTER = 1.0e-6         # centroid at origin
+SEAM_WIDTH = 0.018          # render only: stitched seam width on the ball
+SEAM_LIFT = 0.002           # render only: seam sits this far proud of the ball
+FRAMING_EXIT = 14           # render only: gallery_framing returns 10, taken here
 
 # closed forms for a truncated icosahedron (Goldberg polyhedron GP(1,1))
 EXPECT_V, EXPECT_E, EXPECT_F = 60, 90, 32
@@ -292,16 +300,48 @@ def render_still(obj, path, engine):
     me = obj.data
     _panel_materials(obj)
 
-    # the check reads the base mesh; the still adds an UNAPPLIED Subsurf so
-    # the faceted Goldberg cage reads as an inflated ball. Panel materials
-    # carry through Catmull-Clark per face class, so a misbound panel would
+    # the check reads the base mesh; the still adds UNAPPLIED modifiers so
+    # the faceted Goldberg cage reads as a stitched ball. Panel materials
+    # carry through every stage per face class, so a misbound panel would
     # still show in the image.
     for poly in me.polygons:
         poly.use_smooth = True
     sub = obj.modifiers.new("Inflate", 'SUBSURF')
     sub.subdivision_type = 'CATMULL_CLARK'
-    sub.levels = 2
-    sub.render_levels = 2
+    sub.levels = 3
+    sub.render_levels = 3
+    # Catmull-Clark on a 60-vertex cage leaves flats over the hexagons (the
+    # clay pass reads as a lumpy stone); Cast pulls the surface onto a sphere
+    # of the cage's own circumradius
+    cast = obj.modifiers.new("Round", 'CAST')
+    cast.cast_type = 'SPHERE'
+    cast.factor = 1.0
+    cast.use_radius_as_size = True
+    cast.radius = BALL_RADIUS
+
+    # stitched seams: without them the 20 white hexagons merge into one white
+    # shell and only 12 of the 32 panels the check counts are visible. The
+    # cage's own edges, as a wire subdivided and cast onto a sphere just
+    # proud of the ball, draw every panel boundary. A render-only copy of
+    # the mesh, so the checked mesh and its binding are untouched.
+    seam_me = me.copy()
+    for poly in seam_me.polygons:
+        poly.material_index = 1
+    seams = bpy.data.objects.new("Seams", seam_me)
+    scene.collection.objects.link(seams)
+    seams.parent = obj
+    wire = seams.modifiers.new("Wire", 'WIREFRAME')
+    wire.thickness = SEAM_WIDTH
+    wire.use_replace = True
+    fine = seams.modifiers.new("Follow", 'SUBSURF')
+    fine.subdivision_type = 'SIMPLE'
+    fine.levels = 3
+    fine.render_levels = 3
+    lay = seams.modifiers.new("Lay", 'CAST')
+    lay.cast_type = 'SPHERE'
+    lay.factor = 1.0
+    lay.use_radius_as_size = True
+    lay.radius = BALL_RADIUS + SEAM_LIFT
 
     # a pentagon sits on the icosphere +Z pole; tip it toward the camera and
     # spin for an asymmetric, match-worn panel layout
@@ -362,7 +402,7 @@ def light(name, loc, energy, size, col, rot):
     light("Wedge", (2.5, 5.5, 4.0), 380.0, 6.0, (1.0, 0.76, 0.5), (-68, 0, 190))
 
     cam_data = bpy.data.cameras.new("Cam")
-    cam_data.lens = 55.0
+    cam_data.lens = 50.0
     cam = bpy.data.objects.new("Cam", cam_data)
     cam.location = (0.0, -7.2, 3.8)
     cam.rotation_euler = (math.radians(68), 0.0, 0.0)
@@ -384,8 +424,14 @@ def light(name, loc, energy, size, col, rot):
     # AgX would wash the white leather toward grey and lift the stage
     # (docs/VISUAL-STYLE.md); Standard is the house transform
     scene.view_settings.view_transform = 'Standard'
+    if gallery_framing.check_framing(scene, cam, hero=[obj], elements=[obj],
+                                     stage=[floor, wall]):
+        return FRAMING_EXIT
     bpy.ops.render.render(write_still=True)
-    return os.path.exists(path) and os.path.getsize(path) > 0
+    if not (os.path.exists(path) and os.path.getsize(path) > 0):
+        print("ERROR: render produced no file", file=sys.stderr)
+        return 6
+    return 0
 
 
 def main():
@@ -404,9 +450,9 @@ def main():
         return code
 
     if args.output:
-        if not render_still(obj, os.path.abspath(args.output), args.engine):
-            print("ERROR: render produced no file", file=sys.stderr)
-            return 6
+        rcode = render_still(obj, os.path.abspath(args.output), args.engine)
+        if rcode:
+            return rcode
         print(f"rendered still {args.output}")
 
     print("soccer-ball-goldberg OK")
diff --git a/showcase/README.md b/showcase/README.md
index bad46aea..eb68c845 100644
--- a/showcase/README.md
+++ b/showcase/README.md
@@ -524,6 +524,37 @@ entry in `showcase/gallery.json`, and a rendered still.
   cannot pass vacuously, and aim the falsifier at the joist span with
   the bearers kept, so the triangle floor and envelope do not steal it
   (`--short-joists`, watchtower).
+- **A bent bar is one sweep (file-local code).** Wrought iron that bends
+  from a foot into a post, or from a post into a back, is one bar. Sweep it
+  along one path with parallel-transported frames. Do not stand a post on a
+  separate foot arc. `park-bench` built its scroll feet that way, stopped
+  each arc 8% short, and started each post at the arc's top. That left
+  14 mm of daylight under all four posts. A BVH gap budget can't see this,
+  because the toe still grounds and the post still meets its stretcher.
+  Assert it from shells instead: the shell under each toe station must be a
+  leg that reaches the seat. `--split-feet` is the falsifier.
+- **A carried member bites its carrier, measured where the vertices are
+  (file-local code).** A slat on a rail, a back slat on an upright and an
+  armrest on its leg each assert an overlap depth against a named minimum,
+  and a count of the members, so a dropped slat cannot pass vacuously. A
+  round rail has vertices only at its end rings, so the deepest rail vertex
+  inside a mid-span slat is nowhere near the slat. Take the overlap either
+  way round: under a slat, the slat's corner sits in the rail. Where neither
+  member has a vertex at the crossing — a brace over a rail, mid-span — read
+  both faces off the mesh and compare the planes, only where their heights
+  overlap. `--float-slats` and `--float-brace` are the falsifiers.
+- **A kit section fits its tile (file-local code).** A section that claims
+  to tile at a pitch asserts its width along that axis is at most the tile
+  and within a named band of it. Derive the post stations from the tile
+  minus the reach of whatever is proudest, not from the post's own half
+  width. `fence-kit` placed its posts from the post width alone. Its iron
+  bands then stood 12 mm past each end, so adjacent copies interpenetrated
+  by 24 mm, while its README said the width *was* the tile. `--wide-tile`
+  restores the old stations. Check it before the AABB gate, or the envelope
+  check fires first.
+- **Level on the stage.** A hero that tilts the piece about X, even by 2°,
+  sinks one row of feet into the floor and lifts the other. Turn the piece
+  only about Z.
 - **Laid stone and cut timber vary piece by piece.** One flat grey on
   every stone reads as a moulded ring; one brown on every member reads
   as a single casting. Drive a per-shell tone (`PlankTone`) and, for
diff --git a/showcase/fence-kit/README.md b/showcase/fence-kit/README.md
index 9fcaba36..90f6bc3e 100644
--- a/showcase/fence-kit/README.md
+++ b/showcase/fence-kit/README.md
@@ -1,22 +1,25 @@
 # Fence kit
 
-A showcase piece, not an example. Procedural post-and-rail fence
-section (two posts, pyramidal caps, three rails, kickboard, a brace
-from named post stations, iron shoes and U-wrap straps) then the
-shipped pipeline: unique-cell UVs, Cycles high-to-low normal bake, LOD
-chain, convex collider, Unity glTF export.
-
-Posts, rails, kick, brace and collars share named stations
-(`POST_XS`, `RAIL_ZS`, `Y_BRACE`, `SHOE_H`). The brace is an oriented
-box from the left-post lower-rail station to the right-post upper-rail
-station on the back face, not a hypot-length box rotated about its
-centroid. Rails and kick tenon into the post volume; rail collars are
-U-wraps so the span-facing plate is not coplanar with the rail end.
+A showcase piece, not an example. A procedural post-and-rail fence section
+(two posts, pyramidal caps, three rails, a kickboard, a board brace, iron
+shoes and U-bands), then the shipped pipeline: unique-cell UVs, a Cycles
+high-to-low normal bake, an LOD chain, a convex collider and a Unity glTF
+export.
+
+Posts, rails, kick, brace and bands share named stations (`POST_XS`,
+`RAIL_ZS`, `SHOE_H`). The post stations come from the tile. The outer faces
+of the iron bands sit `KIT_CLEAR` (2 mm) inside the tile edge, so copies
+placed at the 1.60 m pitch meet band to band without interpenetrating or
+sharing a plane. Each band is one shell, mitred at the corners. A rail band
+is a U open toward the span, with its arms stopped inside the post's inner
+face. The brace is a board with plumb-cut ends, face-nailed to the middle
+rail and housed 12 mm into both posts. It clears the bottom rail at the left
+post and the top rail at the right one. Rails and kick tenon into the post
+volume.
 
 It asserts **budget conformance** of the generated result. It does not
-witness an API contract. "It rendered without error" is not a check.
-AABB X is the tile width so adjacent copies meet; this piece does not
-re-witness the `modular-kit-snap` snap contract.
+witness an API contract. "It rendered without error" is not a check. This
+piece does not re-witness the `modular-kit-snap` snap contract.
 
 **Composes** skills `mesh-editing-and-bmesh`, `bake-high-to-low`,
 `depsgraph-and-evaluated-data`, `engine-export-presets`, and snippets
@@ -26,35 +29,37 @@ re-witness the `modular-kit-snap` snap contract.
 Hygiene combinatorics match `examples/mesh-hygiene-audit` (copied, not
 imported).
 
-Intended size: 1.60 m bay, 1.14 m posts, 0.11 m post stock; outer AABB
-1.624 × 0.134 × 1.232 m.
+Intended size: 1.60 m tile, 1.14 m posts, 0.11 m post stock. Outer AABB
+1.596 × 0.134 × 1.232 m.
 
 ## Budgets
 
-Declared as named constants; every gate **recomputes** from the mesh,
-materials, UVs, evaluated LOD, collider, or export file.
+Declared as named constants. Every gate **recomputes** its value from the
+mesh, materials, UVs, evaluated LOD, collider or export file.
 
 | Axis | Declared | Measured (4.5.11 / 5.1.2 / 5.2.1) |
 | --- | --- | --- |
-| Base triangles | 1000–1400 | 1092 / 1092 / 1092 |
+| Base triangles | 850–1200 | 1012 / 1012 / 1012 |
 | 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.1832 |
-| Materials | exactly 2 distinct, ≥48 metal, ≥24 wood | 2 slots, 156 metal / 390 wood |
+| LOD2 ratio | 0.10–0.35 of base | 0.2194 / 0.2194 / 0.2174 |
+| Materials | exactly 2 distinct, ≥48 metal, ≥48 wood | 2 slots, 116 metal / 390 wood |
 | UVs | in `0..1`, AABB overlap ≤ 1e-5 | in range, overlap 0 |
-| Outer AABB | (1.624, 0.134, 1.232) m ± 0.015 | (1.6240, 0.1340, 1.2320), zmin 0 |
-| Collider tris | ≤ 180 | 32 |
-| Export | written, size > 0 | 82216 / 82216 / 82208 bytes |
-
-Base triangles dropped from **1212 to 1092** in the quality pass: rail
-collars became U-wraps (no span-facing plate). Outer AABB tightened from
-1.642 × 0.157 × 1.235 m.
-
-DECIMATE COLLAPSE triangle counts are **not** identical across series —
-5.2.1 is more aggressive on LOD2. The gate is a ratio band, not an
-exact count. Bake pixels are stochastic; the gate is `has_data` plus
-operator `FINISHED`, not byte-identity. Construction uses no RNG.
-Export byte counts differ by 8 B on 5.2.1 (glTF serializer), not a
-gated axis.
+| Outer AABB | (1.596, 0.134, 1.232) m ± 0.015 | (1.5960, 0.1340, 1.2320), zmin 0 |
+| Collider tris | ≤ 180 | 24 |
+| Export | written, size > 0 | 75900 / 75900 / 75888 bytes |
+
+Base triangles dropped from **1092 to 1012** in the second quality pass. Each
+band became one mitred shell instead of three or four separate plates, and
+the brace became a six-face board. The band was re-fitted around the
+measurement and narrowed from 1000–1400.
+
+DECIMATE COLLAPSE triangle counts are **not** identical across series:
+5.2.1 is more aggressive on LOD2. The gate is a ratio band, not an exact
+count. Bake pixels are stochastic; the gate is `has_data` plus operator
+`FINISHED`, not byte-identity. Construction is closed-form and plank tones
+are seeded, so repeated runs on one binary print identical measurements.
+Export byte counts differ by 12 B on 5.2.1 (glTF serializer), not a gated
+axis.
 
 ### Hygiene
 
@@ -71,13 +76,20 @@ Recomputed from the generated mesh, not asserted about the script.
 | Grounded: `zmin` | within 1e-4 of 0 | 0.0000 |
 | Named shoes | 2, each `zmin` ≤ 0.002 | 2, 0.00000 |
 
-### Joint fit and span
+### Joint fit, bearing and tiling
 
 | Axis | Declared | Measured (all three) |
 | --- | --- | --- |
-| Brace-to-post BVH gap (both posts) | ≤ 0.008 m | 0.00240 |
+| Brace-to-post BVH gap (both posts) | ≤ 0.008 m | 0.00531 |
 | Rail-to-post BVH gap | ≤ 0.008 m | 0.00093 |
-| Rail span vs `2·RAIL_HALF` | ± 0.04 m | 1.3900 vs 1.390 |
+| Rail span vs `2·RAIL_HALF` | ± 0.04 m | 1.3620 vs 1.362 |
+| Brace housing (exit 20): deepest brace vertex inside each post | ≥ 0.004 m | 0.01200 |
+| Brace bearing (exit 20): brace back plane past the middle rail's front plane, where their heights overlap | ≥ 0.001 m | 0.00200 |
+| Tile fit (exit 21): section width along the tiling axis | 1.590–1.600 m | 1.5960 |
+
+The brace bearing is measured plane to plane. The brace and the middle rail
+cross mid-span, and neither has a vertex there, so a vertex-depth metric
+reports a false gap of 0.15 m.
 
 ### Falsifiers
 
@@ -93,13 +105,17 @@ and returned the same code on each.
 | `--short-brace` | brace-to-post BVH gap (both posts) | 17 |
 | `--gap-rails` | rail-to-post BVH gap | 18 |
 | `--long-rails` | rail span vs `2·RAIL_HALF` | 19 |
-
-`--short-shoes` lifts only the iron shoes. After recenter a post or kick
-is the AABB `zmin`, so the AABB gate would still pass; the named-shoe
-stations fail. `--short-brace` shortens the left station; `brace_gap` is
-the max of the per-post minima so a brace that still hits the right post
-cannot sneak through. `--long-rails` adds an extra spanning board; the
-tenoned rails stay put so the gap budget still passes.
+| `--float-brace` | brace bearing on the middle rail (brace 6 mm forward; measured −0.00400) | 20 |
+| `--wide-tile` | tile fit (the first build's post stations; measured 1.6240) | 21 |
+
+`--short-shoes` lifts only the iron shoes. After recentring, a post or the
+kick is the AABB `zmin`, so the AABB gate would still pass. The named-shoe
+stations fail. `--short-brace` shortens the left end; `brace_gap` is the
+maximum of the per-post minima, so a brace that still reaches the right post
+cannot sneak through. `--long-rails` adds an extra spanning board, and the
+tenoned rails stay put, so the gap budget still passes. `--wide-tile` moves
+the posts out to where the first build had them and moves the rails with
+them. It is checked before the AABB gate, which it would also fail.
 
 ## Run
 
@@ -112,6 +128,8 @@ blender --background --python fence_kit.py -- --short-shoes
 blender --background --python fence_kit.py -- --short-brace
 blender --background --python fence_kit.py -- --gap-rails
 blender --background --python fence_kit.py -- --long-rails
+blender --background --python fence_kit.py -- --float-brace
+blender --background --python fence_kit.py -- --wide-tile
 blender --background --python fence_kit.py -- --output fence.png
 ```
 
@@ -121,7 +139,7 @@ Smoke passes no flags.
 
 File-local. `9` is a valid check code. `10` is reserved for
 `gallery_framing.check_framing` on the `--output` path. `15`–`19` are the
-hygiene and joint-fit family.
+hygiene and joint-fit family. `20` and `21` are this piece's own.
 
 | Code | Meaning |
 | --- | --- |
@@ -145,3 +163,5 @@ hygiene and joint-fit family.
 | 17 | Brace-to-post gap (`--short-brace`) |
 | 18 | Rail-to-post gap (`--gap-rails`) |
 | 19 | Rail span (`--long-rails`) |
+| 20 | Brace not housed in both posts or not bearing on the middle rail (`--float-brace`) |
+| 21 | Section does not fit its tile (`--wide-tile`) |
diff --git a/showcase/fence-kit/fence_kit.py b/showcase/fence-kit/fence_kit.py
index 1744dcf8..c8da4641 100644
--- a/showcase/fence-kit/fence_kit.py
+++ b/showcase/fence-kit/fence_kit.py
@@ -5,23 +5,25 @@
 materials, high-to-low normal bake, LOD chain, convex collider,
 Unity glTF export.
 
-Posts, rails, kick, brace and collars share named stations
-(``post_xs``, ``RAIL_ZS``, ``y_brace``). The brace is an oriented
-box between those stations, not a hypot-length cube rotated about
-its centroid. Rails and kick tenon into the post volume without
-sharing corner verts.
+Posts, rails, kick, brace and iron bands share named stations
+(``POST_XS``, ``RAIL_ZS``, ``SHOE_H``). The post stations come from the
+tile: the outer face of the iron bands sits ``KIT_CLEAR`` inside the tile
+edge, so adjacent copies meet without interpenetrating. Each band is one
+mitred shell. The brace is a board with plumb-cut ends, face-nailed to
+the middle rail and housed in both posts. Rails and kick tenon into the
+post volume without sharing corner verts.
 
 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. Hygiene family 15–19:
 ``--stray-vert``, ``--lift-z`` / ``--short-shoes``, ``--short-brace``,
-``--gap-rails``, ``--long-rails``.
+``--gap-rails``, ``--long-rails``. ``--float-brace`` fails the brace
+bearing (20); ``--wide-tile`` fails the tile fit (21).
 
-No RNG. Construction is closed-form. AABB X is the tile width so
-adjacent copies meet; this piece does not re-witness the modular-kit
-snap contract. DECIMATE COLLAPSE triangle counts are not byte-identical
-across Blender versions — the LOD gate is a ratio band, not an exact
-count.
+Construction is closed-form; plank tones use a seeded RNG. This piece
+does not re-witness the modular-kit snap contract. 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 fence_kit.py --
     blender --background --python fence_kit.py -- --skip-decimate
@@ -30,6 +32,7 @@
 import argparse
 import math
 import os
+import random
 import sys
 import tempfile
 import traceback
@@ -60,16 +63,32 @@
 IRON_T = 0.016
 SHOE_H = 0.034
 TENON = 0.005
-POST_XS = (-(TILE / 2.0 - POST_W / 2.0), TILE / 2.0 - POST_W / 2.0)
-HX = POST_XS[1]
-Y_BRACE = -(POST_W * 0.5 - BRACE_T * 0.30)
-RAIL_HALF = HX - POST_W * 0.5 + TENON
 COLLAR_BITE = 0.004
+# The section tiles at TILE: the outer face of the iron bands, not the post
+# centre, sits a named clearance inside the tile edge, so neighbouring
+# copies meet band to band without interpenetrating or sharing a plane.
+KIT_CLEAR = 0.002
+TILE_FIT_TOL = 0.010
+WIDE_TILE_CLEAR = -0.012
+BAND_REACH = POST_W / 2.0 - COLLAR_BITE + IRON_T
+HX = TILE / 2.0 - KIT_CLEAR - BAND_REACH
+POST_XS = (-HX, HX)
+RAIL_HALF = HX - POST_W * 0.5 + TENON
+BRACE_D = 0.022
+BRACE_BITE = 0.002
+BRACE_TENON = 0.012
+BRACE_CLEAR = 0.012
+FLOAT_BRACE = 0.006
+BRACE_POST_BITE_MIN = 0.004
+BRACE_RAIL_BITE_MIN = 0.001
+PLANK_TONE_JITTER = 0.28
+TONE_SEED = 17
+WOOD_GRAIN_SCALE = 30.0
 
 BBOX_TOL = 0.015
-OUTER_SIZE = (1.624, 0.134, 1.232)
-BASE_TRIS_MIN = 1000
-BASE_TRIS_MAX = 1400
+OUTER_SIZE = (1.596, 0.134, 1.232)
+BASE_TRIS_MIN = 850
+BASE_TRIS_MAX = 1200
 LOD1_RATIO_MIN = 0.32
 LOD1_RATIO_MAX = 0.62
 LOD2_RATIO_MIN = 0.10
@@ -170,25 +189,78 @@ def add_oriented_box(bm, a, b, scale_xy, mat_idx):
 
 
 def add_collar(bm, px, z, half, t, h, mat_idx, closed=True):
-    """Plates around a post. Bite the host. U-wrap omits the span-facing plate."""
-    loc_y = half - COLLAR_BITE + t * 0.5
-    add_box(bm, (px, loc_y, z), (2.0 * half - t * 0.50, t, h), mat_idx)
-    add_box(bm, (px, -loc_y, z), (2.0 * half - t * 0.50, t, h), mat_idx)
-    loc_x = half - COLLAR_BITE + t * 0.5
-    sign = 1.0 if px >= 0.0 else -1.0
-    add_box(
-        bm,
-        (px + sign * loc_x, 0.0, z),
-        (t, 2.0 * half - t * 0.70, h),
-        mat_idx,
-    )
+    """One iron band around a post, mitred at the corners, one shell.
+
+    Inner face a named bite inside the post, outer face proud of it. A U
+    band (``closed=False``) leaves the span-facing side open for the rail
+    and stops its arms a quarter-thickness inside the post's inner face,
+    so no arm end lands on that face's plane. The first build was three or
+    four separate plates with open slits at every corner.
+    """
+    a = half - COLLAR_BITE
+    b = a + t
+    s = 1.0 if px >= 0.0 else -1.0
     if closed:
-        add_box(
-            bm,
-            (px - sign * loc_x, 0.0, z),
-            (t, 2.0 * half - t * 0.70, h),
-            mat_idx,
-        )
+        outer = [(b, b), (-b, b), (-b, -b), (b, -b)]
+        inner = [(a, a), (-a, a), (-a, -a), (a, -a)]
+    else:
+        e = half - t * 0.25
+        outer = [(-e, -b), (b, -b), (b, b), (-e, b)]
+        inner = [(-e, -a), (a, -a), (a, a), (-e, a)]
+    z0, z1 = z - h * 0.5, z + h * 0.5
+
+    def ring(pts, zz):
+        return [bm.verts.new((px + s * x, y, zz)) for x, y in pts]
+
+    ob, ot = ring(outer, z0), ring(outer, z1)
+    ib, it = ring(inner, z0), ring(inner, z1)
+    n = len(outer)
+    segs = range(n) if closed else range(n - 1)
+    faces = []
+    for i in segs:
+        j = (i + 1) % n
+        faces.append(bm.faces.new((ob[i], ob[j], ot[j], ot[i])))
+        faces.append(bm.faces.new((ib[j], ib[i], it[i], it[j])))
+        faces.append(bm.faces.new((ot[i], ot[j], it[j], it[i])))
+        faces.append(bm.faces.new((ob[j], ob[i], ib[i], ib[j])))
+    if not closed:
+        for i in (0, n - 1):
+            faces.append(bm.faces.new((ob[i], ib[i], it[i], ot[i])))
+    for f in faces:
+        f.material_index = mat_idx
+    return ob + ot + ib + it
+
+
+def add_brace(bm, x0, z0, x1, z1, y_back, depth, height, mat_idx):
+    """A board brace between two posts, ends cut plumb.
+
+    A box rotated onto the diagonal has ends square to its own axis: one
+    corner buries itself in the post and the other stands off in the air.
+    Cut plumb, both ends enter the post faces along their full height.
+    """
+    y_front = y_back - depth
+    vs = []
+    for x, zc in ((x0, z0), (x1, z1)):
+        for y in (y_back, y_front):
+            for dz in (-0.5, 0.5):
+                vs.append(bm.verts.new((x, y, zc + dz * height)))
+    # index: (end, y, z) -> end*4 + y*2 + z
+    q = [
+        (0, 1, 3, 2), (4, 6, 7, 5),       # plumb ends
+        (0, 4, 5, 1), (2, 3, 7, 6),       # back / front faces
+        (0, 2, 6, 4), (1, 5, 7, 3),       # underside / top
+    ]
+    for quad in q:
+        bm.faces.new([vs[i] for i in quad]).material_index = mat_idx
+    return vs
+
+
+def rail_depth(i):
+    return RAIL_Y * (1.0 + 0.10 * math.sin(i * 2.15 + 0.3))
+
+
+def rail_height(i):
+    return RAIL_Z * (1.0 + 0.06 * math.sin(i * 1.7 + 1.1))
 
 
 def add_cone(bm, loc, radius1, radius2, depth, segments, mat_idx, euler=(0.0, 0.0, 0.0)):
@@ -263,13 +335,18 @@ def build_fence_mesh(
     short_shoes=False,
     gap_rails=False,
     long_rails=False,
+    float_brace=False,
+    wide_tile=False,
 ):
     bm = bmesh.new()
     try:
         wood_verts = []
-        post_xs = POST_XS
         half = POST_W * 0.5
-        rail_half = RAIL_HALF - GAP_RAIL if gap_rails else RAIL_HALF
+        hx = TILE / 2.0 - (WIDE_TILE_CLEAR if wide_tile else KIT_CLEAR) - BAND_REACH
+        post_xs = (-hx, hx)
+        rail_half = hx - half + TENON
+        if gap_rails:
+            rail_half -= GAP_RAIL
 
         for px in post_xs:
             wood_verts.extend(
@@ -282,8 +359,8 @@ def build_fence_mesh(
             )
 
         for i, z in enumerate(RAIL_ZS):
-            ry = RAIL_Y * (1.0 + 0.10 * math.sin(i * 2.15 + 0.3))
-            rz = RAIL_Z * (1.0 + 0.06 * math.sin(i * 1.7 + 1.1))
+            ry = rail_depth(i)
+            rz = rail_height(i)
             wood_verts.extend(
                 add_box(bm, (0.0, 0.0, z), (2.0 * rail_half, ry, rz), WOOD_IDX)
             )
@@ -308,14 +385,35 @@ def build_fence_mesh(
                 )
             )
 
-        a = Vector((post_xs[0], Y_BRACE, RAIL_ZS[0]))
-        b = Vector((post_xs[1], Y_BRACE, RAIL_ZS[-1]))
-        if short_brace:
-            a = Vector((post_xs[0] + SHORT_BRACE, Y_BRACE, RAIL_ZS[0]))
-        wood_verts.extend(add_oriented_box(bm, a, b, (BRACE_T, BRACE_T), WOOD_IDX))
+        # The brace is a board face-nailed to the middle rail and housed in
+        # both posts: it clears the bottom rail at the left post and the top
+        # rail at the right one, and its back face bites the middle rail.
+        # The first build ran post centre to post centre through the rail
+        # bands, 6 mm into all three rails, with square-cut ends.
+        x_a = post_xs[0] + half
+        x_b = post_xs[1] - half
+        h = BRACE_T
+        for _ in range(3):
+            z_a = RAIL_ZS[0] + rail_height(0) / 2.0 + BRACE_CLEAR + h / 2.0
+            z_b = RAIL_ZS[-1] - rail_height(len(RAIL_ZS) - 1) / 2.0 - BRACE_CLEAR - h / 2.0
+            slope = (z_b - z_a) / (x_b - x_a)
+            h = BRACE_T * math.sqrt(1.0 + slope * slope)
+        x0 = x_a - BRACE_TENON + (SHORT_BRACE if short_brace else 0.0)
+        x1 = x_b + BRACE_TENON
+        y_back = -rail_depth(1) / 2.0 + BRACE_BITE - (FLOAT_BRACE if float_brace else 0.0)
+        wood_verts.extend(
+            add_brace(
+                bm,
+                x0, z_a + slope * (x0 - x_a),
+                x1, z_a + slope * (x1 - x_a),
+                y_back, BRACE_D, h, WOOD_IDX,
+            )
+        )
 
         if bevel_offset > 0.0:
-            edges = list({e for v in wood_verts for e in v.link_edges})
+            # A set of BMEdges iterates in memory order; sort by index.
+            bm.edges.index_update()
+            edges = sorted({e for v in wood_verts for e in v.link_edges}, key=lambda e: e.index)
             ret = bmesh.ops.bevel(
                 bm,
                 geom=edges,
@@ -394,9 +492,142 @@ def principled(name, color, metallic, roughness, noise_scale=0.0, wear=None):
         fac = mix.inputs.get("Factor") or mix.inputs.get("Fac")
         nt.links.new(tex.outputs["Fac"], fac)
         nt.links.new(mix.outputs["Result"], bsdf.inputs["Base Color"])
+        rmix = nt.nodes.new("ShaderNodeMix")
+        rmix.data_type = "FLOAT"
+        rmix.inputs["A"].default_value = roughness
+        rmix.inputs["B"].default_value = min(1.0, roughness + 0.18)
+        rfac = rmix.inputs.get("Factor") or rmix.inputs.get("Fac")
+        nt.links.new(tex.outputs["Fac"], rfac)
+        nt.links.new(rmix.outputs["Result"], bsdf.inputs["Roughness"])
     return mat
 
 
+def _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 post, rail, kick, brace and cap is its own shell, so each gets
+    one tone and grain along its own long axis. Iron shells get a tone
+    too; the iron shader ignores it.
+    """
+    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 shells(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 _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``)."""
+    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 fence_materials():
+    """(wood, metal): shared by the check, the render and inspection.
+
+    The first build was one flat brown on every member and satin iron
+    (metallic 1.0, roughness 0.28) that read as chrome.
+    """
+    wood = wood_material("FenceWood")
+    metal = principled(
+        "FenceIron", (0.045, 0.046, 0.048, 1.0), 0.60, 0.55,
+        noise_scale=18.0, wear=(0.13, 0.062, 0.028, 1.0),
+    )
+    return wood, metal
+
+
 def assign_slots(obj, wood, metal):
     # Do not materials.clear() — that resets polygon material_index to 0
     # on this Blender, which would drop metal faces onto wood.
@@ -613,6 +844,32 @@ def add_stray_vert(me):
         bm.free()
 
 
+def shell_bite(me, ga, gb):
+    """Deepest vertex of shell ``ga`` inside closed shell ``gb`` (m); negative if none is."""
+    bm_b = bmesh.new()
+    try:
+        bm_b.from_mesh(me)
+        keep_b = set(gb)
+        drop_b = [f for f in bm_b.faces if not all(v.index in keep_b for v in f.verts)]
+        if drop_b:
+            bmesh.ops.delete(bm_b, geom=drop_b, context="FACES")
+        if not bm_b.faces:
+            return -1e9
+        bmesh.ops.recalc_face_normals(bm_b, faces=list(bm_b.faces))
+        tree = BVHTree.FromBMesh(bm_b)
+        best = -1e9
+        for i in ga:
+            co = me.vertices[i].co
+            loc, nrm, _idx, dist = tree.find_nearest(co)
+            if loc is None:
+                continue
+            depth = dist if (co - loc).dot(nrm) < 0.0 else -dist
+            best = max(best, depth)
+        return best
+    finally:
+        bm_b.free()
+
+
 def joint_audit(me):
     groups = shells(me)
     posts = []
@@ -652,7 +909,25 @@ def joint_audit(me):
     if rails:
         xs = [v for _g, a in rails for v in (a[0], a[3])]
         span_x = max(xs) - min(xs)
+    # The brace is housed in both posts (deepest brace vertex inside each
+    # post) and bears on the middle rail. Neither has a vertex where they
+    # cross mid-span, so the bearing is the brace's back plane measured
+    # against the rail's front plane, both read off the mesh, and only
+    # counted where their heights overlap.
+    post_bites = [shell_bite(me, b[0], p[0]) for b in braces for p in posts]
+    brace_post_bite = min(post_bites) if post_bites else -1.0
+    brace_rail_bite = -1.0
+    if braces and rails:
+        # The middle rail is the one centred on its station, whatever its
+        # length, so a falsifier that moves the posts still finds it.
+        mid = min(rails, key=lambda r: abs(0.5 * (r[1][2] + r[1][5]) - RAIL_ZS[1]))[1]
+        brace_rail_bite = min(
+            (b[1][4] - mid[1]) if (b[1][2] < mid[5] and b[1][5] > mid[2]) else -1.0
+            for b in braces
+        )
     return {
+        "brace_post_bite": brace_post_bite,
+        "brace_rail_bite": brace_rail_bite,
         "posts": len(posts),
         "rails": len(rails),
         "braces": len(braces),
@@ -724,6 +999,8 @@ def check(
     short_shoes=False,
     gap_rails=False,
     long_rails=False,
+    float_brace=False,
+    wide_tile=False,
 ):
     bpy.ops.wm.read_factory_settings(use_empty=True)
     kw = dict(
@@ -731,17 +1008,14 @@ def check(
         short_shoes=short_shoes,
         gap_rails=gap_rails,
         long_rails=long_rails,
+        float_brace=float_brace,
+        wide_tile=wide_tile,
     )
     low = build_fence_mesh("FenceLow", bevel_offset=0.006, bevel_segments=2, **kw)
     high = build_fence_mesh("FenceHigh", bevel_offset=0.006, bevel_segments=4, **kw)
-    wood = principled(
-        "FenceWood", (0.46, 0.24, 0.08, 1.0), 0.0, 0.55,
-        noise_scale=16.0, wear=(0.32, 0.16, 0.05, 1.0),
-    )
-    metal = principled(
-        "FenceIron", (0.11, 0.115, 0.13, 1.0), 1.0, 0.28,
-        noise_scale=20.0, wear=(0.18, 0.16, 0.12, 1.0),
-    )
+    paint_planks(low.data)
+    paint_planks(high.data)
+    wood, metal = fence_materials()
     assign_slots(low, wood, metal)
     assign_slots(high, wood, metal)
 
@@ -797,6 +1071,9 @@ 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):
+        # Measured; do not leave a .glb per run in the temp directory.
+        os.remove(export_path)
 
     hyg = hygiene_audit(low.data)
     zf = zfight_pairs(low.data)
@@ -830,6 +1107,10 @@ def check(
         f"shoe_z={jnt['shoe_z']:.5f} brace_gap={jnt['brace_gap']:.5f} "
         f"rail_gap={jnt['rail_gap']:.5f} span_x={jnt['span_x']:.4f}"
     )
+    print(
+        f"measured brace_post_bite={jnt['brace_post_bite']:.5f} "
+        f"brace_rail_bite={jnt['brace_rail_bite']:.5f} tile={TILE} size_x={size_x:.4f}"
+    )
 
     if not (BASE_TRIS_MIN <= base_tris <= BASE_TRIS_MAX):
         return fail(
@@ -887,6 +1168,21 @@ def check(
             f"rail span {jnt['span_x']:.4f} off {2.0 * RAIL_HALF}",
             19,
         ), None, None, None, None, None
+    if (
+        jnt["brace_post_bite"] < BRACE_POST_BITE_MIN
+        or jnt["brace_rail_bite"] < BRACE_RAIL_BITE_MIN
+    ):
+        return fail(
+            f"brace housing {jnt['brace_post_bite']:.5f} < {BRACE_POST_BITE_MIN} "
+            f"or rail bearing {jnt['brace_rail_bite']:.5f} < {BRACE_RAIL_BITE_MIN}",
+            20,
+        ), None, None, None, None, None
+    if not (TILE - TILE_FIT_TOL <= size_x <= TILE):
+        return fail(
+            f"section width {size_x:.4f} does not fit the {TILE} m tile "
+            f"(band {TILE - TILE_FIT_TOL:.3f}-{TILE})",
+            21,
+        ), None, None, None, None, None
     if (
         abs(size_x - OUTER_SIZE[0]) > BBOX_TOL
         or abs(size_y - OUTER_SIZE[1]) > BBOX_TOL
@@ -950,13 +1246,13 @@ def render_still(low, wood, tex, path, engine):
             ob.hide_render = True
             ob.hide_viewport = True
 
+    # Level on the floor: an X tilt sinks one face of the shoes.
     low.rotation_euler.z = math.radians(-16.0)
-    low.rotation_euler.x = math.radians(2.0)
 
     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()
@@ -1050,6 +1346,8 @@ def main():
     p.add_argument("--short-brace", action="store_true")
     p.add_argument("--gap-rails", action="store_true")
     p.add_argument("--long-rails", action="store_true")
+    p.add_argument("--float-brace", action="store_true")
+    p.add_argument("--wide-tile", action="store_true")
     args = p.parse_args(argv)
 
     code, low, _high, wood, tex, _col = check(
@@ -1060,6 +1358,8 @@ def main():
         short_shoes=args.short_shoes,
         gap_rails=args.gap_rails,
         long_rails=args.long_rails,
+        float_brace=args.float_brace,
+        wide_tile=args.wide_tile,
     )
     if code:
         return code
diff --git a/showcase/fence-kit/preview.webp b/showcase/fence-kit/preview.webp
index 7a710a26..9f22b889 100644
Binary files a/showcase/fence-kit/preview.webp and b/showcase/fence-kit/preview.webp differ
diff --git a/showcase/gallery.json b/showcase/gallery.json
index 7525aecf..e182eee7 100644
--- a/showcase/gallery.json
+++ b/showcase/gallery.json
@@ -114,9 +114,9 @@
     {
       "name": "fence-kit",
       "dir": "showcase/fence-kit",
-      "teaches": "A procedural post-and-rail fence section whose brace is an oriented box between named post stations, through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.",
-      "alt": "A section of wooden post-and-rail fence with a diagonal brace and dark iron collars.",
-      "witnessesFix": "Recomputed: 1092 tris, two materials with 156 metal and 390 wood faces, UVs in 0..1 with zero AABB overlap, outer AABB 1.624×0.134×1.232 m, grounded zmin, 2 iron shoes, brace-to-post gap 2.4 mm on both posts, rail-to-post gap 0.93 mm, rail span 1.390 m, LOD ratios in band (5.2 COLLAPSE leaner on LOD2), convex collider 32 tris, hygiene all zero, non-empty glTF. --skip-decimate exits 9; --stray-vert 15; --lift-z/--short-shoes 16; --short-brace 17; --gap-rails 18; --long-rails 19.",
+      "teaches": "A procedural post-and-rail fence section that fits its 1.60 m tile, with one-shell iron bands and a board brace housed in both posts, through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.",
+      "alt": "A section of grained timber post-and-rail fence with a diagonal board brace across the rails and dark iron bands and shoes on both posts.",
+      "witnessesFix": "Recomputed: 1012 tris, two materials with 116 metal and 390 wood faces, UVs in 0..1 with zero AABB overlap, outer AABB 1.596×0.134×1.232 m inside the 1.60 m tile, grounded zmin, 2 iron shoes, brace housed 12 mm in both posts and bearing 2 mm on the middle rail, rail-to-post gap 0.93 mm, rail span 1.362 m, LOD ratios in band (5.2 COLLAPSE leaner on LOD2), convex collider 24 tris, hygiene all zero, non-empty glTF. --skip-decimate exits 9; --stray-vert 15; --lift-z/--short-shoes 16; --short-brace 17; --gap-rails 18; --long-rails 19; --float-brace 20; --wide-tile 21.",
       "hero": "docs/gallery/assets/fence-kit-hero.webp",
       "preview": "showcase/fence-kit/preview.webp",
       "tags": [
@@ -154,9 +154,9 @@
     {
       "name": "park-bench",
       "dir": "showcase/park-bench",
-      "teaches": "A procedural wrought-iron park bench with tangent tube scroll feet through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.",
-      "alt": "A park bench of wooden slats on a wrought-iron frame with scrolled feet and armrests.",
-      "witnessesFix": "Recomputed: 2520 tris, two materials with 540 metal and 756 wood faces, UVs in 0..1 with zero AABB overlap, outer AABB 1.295×0.632×0.884 m, grounded zmin, 4 named toes, stretcher gap 1.2 mm, slat gap 0.3 mm, seat span 1.272 m, LOD ratios in band, convex collider 82 tris, hygiene zero, non-empty glTF. --skip-decimate exits 9; --stray-vert 15; --lift-z/--short-feet 16; --float-stretcher 17; --gap-slats 18; --narrow-seat 19.",
+      "teaches": "A procedural wrought-iron park bench whose legs are each one bent bar from scroll toe to reclined back, through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.",
+      "alt": "A park bench of grained wooden slats with a reclined back, on a dark wrought-iron frame whose round-bar legs curl into scrolled feet, with armrests on curved brackets.",
+      "witnessesFix": "Recomputed: 3272 tris, two materials with 1008 metal and 756 wood faces, UVs in 0..1 with zero AABB overlap, outer AABB 1.295×0.632×0.887 m, grounded zmin, 4 named toes, 4 legs each one bar from toe to seat, back reclined 12°, 28 slat and armrest bites of at least 2.0 mm, stretcher gap 1.1 mm, seat span 1.272 m, LOD ratios in band, convex collider 64 tris, hygiene zero, non-empty glTF. --skip-decimate exits 9; --stray-vert 15; --lift-z/--short-feet 16; --float-stretcher 17; --gap-slats 18; --narrow-seat/--upright-back 19; --float-slats 20; --split-feet 21.",
       "hero": "docs/gallery/assets/park-bench-hero.webp",
       "preview": "showcase/park-bench/preview.webp",
       "tags": [
diff --git a/showcase/park-bench/README.md b/showcase/park-bench/README.md
index 57b7df57..d339bcd3 100644
--- a/showcase/park-bench/README.md
+++ b/showcase/park-bench/README.md
@@ -1,16 +1,19 @@
 # Park bench
 
-A showcase piece, not an example. Procedural wrought-iron park bench
-(quarter-circle tube scroll feet tangent to the posts, slatted seat and
-back, arm scrolls, wood arm caps) then the shipped pipeline: unique-cell
-UVs, Cycles high-to-low normal bake, LOD chain, convex collider, Unity
-glTF export.
-
-Posts, feet, stretchers and arms share named stations (`hx`, `hy`,
-`SEAT_Z`, `ARM_Z`, `SCROLL_R`). A foot is a 6-gon tube about
-`(hy ± R, R)` so it is tangent to the post at `z=R` and plants at `z=0`.
-The H-stretcher meets the posts at those stations; slats insert into the
-post volume without sharing corner verts with the seat rails.
+A showcase piece, not an example. A procedural wrought-iron park bench
+(round-bar legs bent in one piece from scroll toe to post, with the rear pair
+bending again into a reclined back; a slatted seat and back; armrests on
+quarter-round brackets), then the shipped pipeline: unique-cell UVs, a Cycles
+high-to-low normal bake, an LOD chain, a convex collider and a Unity glTF
+export.
+
+Every leg is one bar swept along one path: a quarter-circle toe about
+`(hy ± R, R)`, tangent to the post where it meets it, then the post, and at
+the back a 12° bend into the upright that carries the back slats. The seat
+slats bear on the side rails, the back slats on the uprights, and each
+armrest on its arm bar and the front leg's tenon, each by a named bite. The
+H-stretcher meets the legs at the shared stations (`HX`, `HY`, `SEAT_Z`,
+`ARM_Z`, `SCROLL_R`, `BACK_TOP`).
 
 It asserts **budget conformance** of the generated result. It does not
 witness an API contract. "It rendered without error" is not a check.
@@ -24,34 +27,37 @@ Hygiene combinatorics match `examples/mesh-hygiene-audit` (copied, not
 imported).
 
 Intended size: 1.40 m sitting width, 0.50 m seat depth, 0.43 m seat
-height, 0.64 m arm height; outer AABB 1.295 × 0.632 × 0.884 m.
+height, 0.64 m arm height, back reclined 12°. Outer AABB
+1.295 × 0.632 × 0.887 m.
 
 ## Budgets
 
-Declared as named constants; every gate **recomputes** from the mesh,
-materials, UVs, evaluated LOD, collider, or export file.
+Declared as named constants. Every gate **recomputes** its value from the
+mesh, materials, UVs, evaluated LOD, collider or export file.
 
 | Axis | Declared | Measured (4.5.11 / 5.1.2 / 5.2.1) |
 | --- | --- | --- |
-| Base triangles | 2200–4200 | 2520 / 2520 / 2520 |
+| Base triangles | 2900–3700 | 3272 / 3272 / 3272 |
 | LOD1 ratio | 0.32–0.62 of base | 0.5000 / 0.5000 / 0.5000 |
-| LOD2 ratio | 0.10–0.35 of base | 0.2198 / 0.2198 / 0.2198 |
-| Materials | exactly 2 distinct, ≥48 metal, ≥24 wood | 2 slots, 540 metal / 756 wood |
+| LOD2 ratio | 0.10–0.35 of base | 0.2194 / 0.2194 / 0.2194 |
+| Materials | exactly 2 distinct, ≥48 metal, ≥24 wood | 2 slots, 1008 metal / 756 wood |
 | UVs | in `0..1`, AABB overlap ≤ 1e-5 | in range, overlap 0 |
-| Outer AABB | (1.295, 0.632, 0.884) m ± 0.015 | (1.2945, 0.6314, 0.8840), zmin 0 |
-| Collider tris | ≤ 180 | 82 |
-| Export | written, size > 0 | 188164 / 188164 / 188148 bytes |
+| Outer AABB | (1.295, 0.632, 0.887) m ± 0.015 | (1.2945, 0.6316, 0.8870), zmin 0 |
+| Collider tris | ≤ 180 | 64 |
+| Export | written, size > 0 | 245620 / 245620 / 245604 bytes |
 
-Base triangles rose from **2100 to 2520** in the quality pass: box-segment
-scrolls became 6-gon tubes. Outer AABB widened from 1.080 × 0.566 × 0.853 m
-to a 1.40 m sitting-width bench.
+Base triangles rose from **2520 to 3272** in the second quality pass. The
+square posts and 6-gon scroll tubes became 8-gon round bar swept along each
+leg, the back gained its bend, and armrest brackets were added. The band was
+re-fitted around the measurement and narrowed from 2200–4200.
 
 DECIMATE COLLAPSE triangle counts are **not** guaranteed identical across
-series — the gate is a ratio band, not an exact count. This mesh matched
-on 4.5.11 / 5.1.2 / 5.2.1. Bake pixels are stochastic; the gate is
-`has_data` plus operator `FINISHED`, not byte-identity. Construction uses
-no RNG. Export byte counts differ by 16 B on 5.2.1 (glTF serializer), not
-a gated axis.
+series — the gate is a ratio band, not an exact count. This mesh matched on
+4.5.11 / 5.1.2 / 5.2.1. Bake pixels are stochastic; the gate is `has_data`
+plus operator `FINISHED`, not byte-identity. Slat widths are closed-form and
+plank tones are seeded, so repeated runs on one binary print identical
+measurements. Export byte counts differ by 16 B on 5.2.1 (glTF serializer),
+not a gated axis.
 
 ### Hygiene
 
@@ -68,13 +74,20 @@ Recomputed from the generated mesh, not asserted about the script.
 | Grounded: `zmin` | within 1e-4 of 0 | 0.0000 |
 | Named toes | 4, each `zmin` ≤ 0.002 | 4, 0.00000 |
 
-### Joint fit and seat
+### Joint fit, bearing and form
 
 | Axis | Declared | Measured (all three) |
 | --- | --- | --- |
-| Stretcher-to-post BVH gap | ≤ 0.008 m | 0.00120 |
-| Slat-to-post BVH gap | ≤ 0.008 m | 0.00028 |
+| Stretcher-to-leg BVH gap | ≤ 0.008 m | 0.00111 |
+| Slat-to-leg BVH gap | ≤ 0.008 m | 0.00016 |
 | Seat span vs `2·hx` | ± 0.08 m | 1.2720 vs 1.260 |
+| Bearing bite (exit 20): 7 seat slats × 2 side rails, 5 back slats × 2 uprights, 2 armrests × (front leg + arm bar), overlap depth either way round | 28 bites, each ≥ 0.0015 m | 28, min 0.00201 |
+| Legs in one piece (exit 21): the shell under each toe station is a leg reaching the seat | 4 | 4 |
+| Back recline (exit 19): each upright, from a low and a high slab centroid | 9°–16° | 12.00° / 12.00° |
+
+The bearing bite takes the overlap either way round. A round rail has
+vertices only at its end rings, so under a mid-span slat it is the slat's
+corner that sits in the rail, not a rail vertex in the slat.
 
 ### Falsifiers
 
@@ -87,13 +100,20 @@ and returned the same code on each.
 | `--stray-vert` | loose vertex count is 0 | 15 |
 | `--lift-z` | bounding box `zmin` is 0 | 16 |
 | `--short-feet` | named toes plant at z=0 | 16 |
-| `--float-stretcher` | stretcher-to-post BVH gap | 17 |
-| `--gap-slats` | slat-to-post BVH gap | 18 |
+| `--float-stretcher` | stretcher-to-leg BVH gap | 17 |
+| `--gap-slats` | slat-to-leg BVH gap | 18 |
 | `--narrow-seat` | seat span vs `2·hx` | 19 |
-
-`--short-feet` lifts only the outward toe verts. After recenter the post
-join is the AABB `zmin`, so the AABB gate would still pass; the named-toe
-stations fail.
+| `--upright-back` | back recline band (measured 0.00°) | 19 |
+| `--float-slats` | bearing bite (seat slats 6 mm up; measured −0.00354) | 20 |
+| `--split-feet` | legs in one piece (measured 0 of 4) | 21 |
+
+`--short-feet` lifts only the outward toe verts. After recentring, the
+bottom of the scroll is the AABB `zmin`, so the AABB gate would still pass.
+The named-toe stations fail. `--split-feet` restores the first build: each
+foot is an arc stopped short of its post, and each post starts at the arc's
+top. The toes still ground and every gap budget still passes. Only the
+one-piece budget sees the 14 mm of daylight. `--upright-back` keeps the back
+top where it was, so the envelope does not move.
 
 ## Run
 
@@ -106,6 +126,9 @@ blender --background --python park_bench.py -- --short-feet
 blender --background --python park_bench.py -- --float-stretcher
 blender --background --python park_bench.py -- --gap-slats
 blender --background --python park_bench.py -- --narrow-seat
+blender --background --python park_bench.py -- --upright-back
+blender --background --python park_bench.py -- --float-slats
+blender --background --python park_bench.py -- --split-feet
 blender --background --python park_bench.py -- --output bench.png
 ```
 
@@ -115,7 +138,7 @@ Smoke passes no flags.
 
 File-local. `9` is a valid check code. `10` is reserved for
 `gallery_framing.check_framing` on the `--output` path. `15`–`19` are the
-hygiene and joint-fit family.
+hygiene and joint-fit family. `20` and `21` are this piece's own.
 
 | Code | Meaning |
 | --- | --- |
@@ -136,6 +159,8 @@ hygiene and joint-fit family.
 | 14 | `--output` produced no file |
 | 15 | Hygiene (`--stray-vert` lands here) |
 | 16 | Grounded zmin / named toes (`--lift-z`, `--short-feet`) |
-| 17 | Stretcher-to-post gap (`--float-stretcher`) |
-| 18 | Slat-to-post gap (`--gap-slats`) |
-| 19 | Seat span (`--narrow-seat`) |
+| 17 | Stretcher-to-leg gap (`--float-stretcher`) |
+| 18 | Slat-to-leg gap (`--gap-slats`) |
+| 19 | Seat span (`--narrow-seat`) or back recline (`--upright-back`) |
+| 20 | Bearing bite on slats and armrests (`--float-slats`) |
+| 21 | Legs not bent in one piece from toe to seat (`--split-feet`) |
diff --git a/showcase/park-bench/park_bench.py b/showcase/park-bench/park_bench.py
index 4fd1cea6..9f717de2 100644
--- a/showcase/park-bench/park_bench.py
+++ b/showcase/park-bench/park_bench.py
@@ -1,22 +1,26 @@
 """Game-ready park bench — a showcase piece, not an example.
 
-Asserts budget conformance of a procedural wrought-iron bench (quarter-
-circle scroll feet tangent to the posts, slatted seat and back, arm
-scrolls) after composing shipped pipeline pieces: bmesh construction,
-UVs, two materials, high-to-low normal bake, LOD chain, convex collider,
-Unity glTF export.
-
-Posts, feet, stretchers and arms share named stations (hx, hy, SEAT_Z,
-ARM_Z, SCROLL_R). A foot is a quarter-circle about (hy ± R, R) so it is
-tangent to the post at z=R and plants at z=0.
+Asserts budget conformance of a procedural wrought-iron bench after
+composing shipped pipeline pieces: bmesh construction, UVs, two
+materials, high-to-low normal bake, LOD chain, convex collider, Unity
+glTF export.
+
+Every leg is one round bar swept along one path: a quarter-circle toe
+scroll about (hy ± R, R), the post, and at the back a bend into the
+reclined upright that carries the back slats. Seat slats bear on the side
+rails, back slats on the uprights, armrests on the arm bar and the front
+leg's tenon, each by a named bite. Stations are shared (HX, HY, SEAT_Z,
+ARM_Z, SCROLL_R, BACK_TOP).
 
 Budgets are declared below and recomputed from the generated result.
 They are not API-contract witnesses. Each falsifier violates one named
 budget: ``--skip-decimate`` LOD, ``--stray-vert`` hygiene, ``--lift-z``
 zmin, ``--short-feet`` named toes, ``--float-stretcher`` stretcher seat,
-``--gap-slats`` slat-to-rail, ``--narrow-seat`` sitting width.
+``--gap-slats`` slat-to-leg, ``--narrow-seat`` sitting width,
+``--float-slats`` bearing bite (20), ``--split-feet`` legs in one piece
+(21), ``--upright-back`` back recline (19).
 
-No RNG. Slat widths use closed-form ``sin(i)``. DECIMATE COLLAPSE
+Slat widths use closed-form ``sin(i)``; plank tones use a seeded RNG. DECIMATE COLLAPSE
 triangle counts are not byte-identical across Blender versions — the LOD
 gate is a ratio band, not an exact count.
 
@@ -27,6 +31,7 @@
 import argparse
 import math
 import os
+import random
 import sys
 import tempfile
 import traceback
@@ -58,15 +63,31 @@
 STRETCHER_Z = 0.16
 POST_INSET_X = 0.07
 POST_INSET_Y = 0.045
+BAR_R = IRON_T / 2.0
+TUBE_SEGS = 8
+RECLINE_DEG = 12.0
+BEND_R = 0.10
+BEND_N = 4
+UPRIGHT_N = 4
+TOP_RAIL_R = BAR_R * 1.25
+BACK_TOP = SEAT_Z + SLAT_T + BACK_H + 0.02
+BACK_CLEAR = 0.012
+SLAT_BITE = 0.003
+ARM_OVER = 0.075
+ARM_TENON = 0.004
+LEG_TENON = 0.012
+BRACKET_R = 0.05
+BRACKET_N = 8
+BRACKET_BITE = 0.008
 HX = SEAT_W / 2.0 - POST_INSET_X
 HY = SEAT_D / 2.0 - POST_INSET_Y
 SEAT_SPAN = 2.0 * HX
 SEAT_SPAN_TOL = 0.08
 
 BBOX_TOL = 0.015
-OUTER_SIZE = (1.295, 0.632, 0.884)
-BASE_TRIS_MIN = 2200
-BASE_TRIS_MAX = 4200
+OUTER_SIZE = (1.295, 0.632, 0.887)
+BASE_TRIS_MIN = 2900
+BASE_TRIS_MAX = 3700
 LOD1_RATIO_MIN = 0.32
 LOD1_RATIO_MAX = 0.62
 LOD2_RATIO_MIN = 0.10
@@ -95,6 +116,14 @@
 SHORT_FOOT = 0.16
 LIFT_Z = 0.05
 NARROW_SEAT = 0.55
+LEG_COUNT = 4
+BITE_MIN = 0.0015
+FLOAT_SLATS = 0.006
+RECLINE_MIN_DEG = 9.0
+RECLINE_MAX_DEG = 16.0
+PLANK_TONE_JITTER = 0.28
+TONE_SEED = 23
+WOOD_GRAIN_SCALE = 30.0
 
 WOOD_IDX = 0
 METAL_IDX = 1
@@ -164,70 +193,89 @@ def add_oriented_box(bm, a, b, scale_xy, mat_idx):
     )
 
 
-def add_arc_yz(bm, x, cy, cz, radius, a0, a1, n, thick, mat_idx, t0=0.0, t1=1.0):
-    pts = []
-    for i in range(n + 1):
-        t = t0 + (t1 - t0) * (i / n)
-        ang = a0 + (a1 - a0) * t
-        pts.append(Vector((x, cy + radius * math.cos(ang), cz + radius * math.sin(ang))))
-    rings = 6
-    r = thick * 0.5
-    ring_verts = []
-    for i, p in enumerate(pts):
-        if i < n:
-            tangent = (pts[i + 1] - p).normalized()
+def add_sweep(bm, pts, radius, mat_idx, segs=None):
+    """Round bar along a polyline, parallel-transported frames, fan caps.
+
+    Every leg is one sweep: the toe scroll, the post and (at the back) the
+    reclined upright are a single bar, the way a smith bends it. A foot
+    built as its own arc under a separate post leaves daylight at the join.
+    """
+    segs = segs or TUBE_SEGS
+    pts = [Vector(p) for p in pts]
+    n = len(pts)
+    tangents = []
+    for i in range(n):
+        if i == 0:
+            t = pts[1] - pts[0]
+        elif i == n - 1:
+            t = pts[-1] - pts[-2]
         else:
-            tangent = (p - pts[i - 1]).normalized()
-        side = tangent.cross(Vector((1.0, 0.0, 0.0)))
-        if side.length < 1e-6:
-            side = tangent.cross(Vector((0.0, 1.0, 0.0)))
-        side.normalize()
-        up = tangent.cross(side).normalized()
+            t = (pts[i + 1] - pts[i]).normalized() + (pts[i] - pts[i - 1]).normalized()
+        tangents.append(t.normalized())
+    t0 = tangents[0]
+    ref = Vector((1.0, 0.0, 0.0)) if abs(t0.x) < 0.9 else Vector((0.0, 0.0, 1.0))
+    side = t0.cross(ref).normalized()
+    rings = []
+    for i, p in enumerate(pts):
+        t = tangents[i]
+        if i > 0:
+            side = tangents[i - 1].rotation_difference(t) @ side
+            side = (side - t * side.dot(t)).normalized()
+        up = t.cross(side).normalized()
         ring = []
-        for k in range(rings):
-            ang = (2.0 * math.pi * k) / rings
-            offset = side * math.cos(ang) * r + up * math.sin(ang) * r
-            ring.append(bm.verts.new(p + offset))
-        ring_verts.append(ring)
-    bm.verts.ensure_lookup_table()
-    bm.faces.ensure_lookup_table()
-    for a, b in zip(ring_verts, ring_verts[1:]):
-        for k in range(rings):
-            k2 = (k + 1) % rings
-            face = bm.faces.new((a[k], a[k2], b[k2], b[k]))
-            face.material_index = mat_idx
-    for end_i, p in ((0, pts[0]), (-1, pts[-1])):
-        center = bm.verts.new(p)
-        ring = ring_verts[end_i]
-        for k in range(rings):
-            k2 = (k + 1) % rings
-            if end_i == 0:
-                face = bm.faces.new((center, ring[k2], ring[k]))
-            else:
-                face = bm.faces.new((center, ring[k], ring[k2]))
-            face.material_index = mat_idx
-    return [v for ring in ring_verts for v in ring]
-
-
-def add_foot_scroll(bm, x, y_post, y_out, thick, mat_idx):
-    """Quarter-circle from post join (y_post, R) to toe (y_out, 0)."""
-    cy = y_out
-    cz = SCROLL_R
-    if y_out < y_post:
-        a0, a1 = 0.0, -math.pi / 2.0
-    else:
-        a0, a1 = math.pi, 1.5 * math.pi
-    return add_arc_yz(
-        bm, x, cy, cz, SCROLL_R, a0, a1, SCROLL_N, thick, mat_idx, t0=0.08, t1=1.0
-    )
-
-
-def add_arm_scroll(bm, x, y_post, thick, mat_idx):
-    cy = y_post - ARM_SCROLL_R
-    cz = ARM_Z
-    return add_arc_yz(
-        bm, x, cy, cz, ARM_SCROLL_R, 0.0, -math.pi / 2.0, 8, thick, mat_idx, t0=0.08, t1=1.0
-    )
+        for k in range(segs):
+            a = 2.0 * math.pi * k / segs
+            ring.append(bm.verts.new(p + (side * math.cos(a) + up * math.sin(a)) * radius))
+        rings.append(ring)
+    for a, b in zip(rings, rings[1:]):
+        for k in range(segs):
+            k2 = (k + 1) % segs
+            bm.faces.new((a[k], a[k2], b[k2], b[k])).material_index = mat_idx
+    for ring, p, flip in ((rings[0], pts[0], True), (rings[-1], pts[-1], False)):
+        c = bm.verts.new(p)
+        for k in range(segs):
+            k2 = (k + 1) % segs
+            f = bm.faces.new((c, ring[k2], ring[k]) if flip else (c, ring[k], ring[k2]))
+            f.material_index = mat_idx
+    return [v for ring in rings for v in ring]
+
+
+def toe_arc(y_post, outward):
+    """Quarter circle from the toe (on the floor) up to the post at z=R.
+
+    Centre ``(y_post + outward*R, R)``: horizontal at the toe, tangent to
+    the post where it meets it. Returned toe first.
+    """
+    cy = y_post + outward * SCROLL_R
+    pts = []
+    for i in range(SCROLL_N + 1):
+        a = -0.5 * math.pi * (1.0 - i / SCROLL_N)
+        pts.append((cy - outward * SCROLL_R * math.cos(a), SCROLL_R + SCROLL_R * math.sin(a)))
+    return pts
+
+
+def rear_leg_path(recline):
+    """(y, z) centreline of a rear leg: toe, post, bend, reclined upright."""
+    pts = toe_arc(HY, 1.0)
+    pts.append((HY, SEAT_Z))
+    # No bend at zero recline: its points would all land on one spot.
+    for i in range(1, BEND_N + 1 if recline > 0.0 else 1):
+        ph = recline * i / BEND_N
+        pts.append((HY + BEND_R * (1.0 - math.cos(ph)), SEAT_Z + BEND_R * math.sin(ph)))
+    y_f, z_f = pts[-1]
+    y_t = y_f + (BACK_TOP - z_f) * math.tan(recline)
+    for i in range(1, UPRIGHT_N + 1):
+        f = i / UPRIGHT_N
+        pts.append((y_f + (y_t - y_f) * f, z_f + (BACK_TOP - z_f) * f))
+    return pts
+
+
+def path_y_at(path, z):
+    """y of a (y, z) path where it first crosses height z."""
+    for (y0, z0), (y1, z1) in zip(path, path[1:]):
+        if (z0 - z) * (z1 - z) <= 0.0 and abs(z1 - z0) > 1e-9:
+            return y0 + (y1 - y0) * (z - z0) / (z1 - z0)
+    return path[-1][0]
 
 
 def pack_uvs(bm, margin=0.08):
@@ -281,18 +329,28 @@ def build_bench_mesh(
     gap_slats=False,
     short_feet=False,
     narrow_seat=False,
+    float_slats=False,
+    split_feet=False,
+    upright_back=False,
 ):
     bm = bmesh.new()
     try:
         wood = []
         t = IRON_T
+        r = BAR_R
         hx, hy = HX, HY
+        recline = 0.0 if upright_back else math.radians(RECLINE_DEG)
+        rear = rear_leg_path(recline)
         slat_span = SEAT_SPAN + t * 0.50
         if gap_slats:
             slat_span = SEAT_SPAN - IRON_T - 0.024
         if narrow_seat:
             slat_span = SEAT_SPAN * NARROW_SEAT
 
+        # Seat slats bear on the side rails: the bottom face sits a named
+        # bite below the rail's top line, so each slat is carried.
+        rail_z = SEAT_Z - t * 0.35
+        slat_z0 = rail_z + r - SLAT_BITE + (FLOAT_SLATS if float_slats else 0.0)
         usable = 2.0 * hy - 0.06
         gap = 0.010
         widths = []
@@ -306,43 +364,62 @@ def build_bench_mesh(
             wood.extend(
                 add_box(
                     bm,
-                    (0.0, y, SEAT_Z + SLAT_T / 2.0),
+                    (0.0, y, slat_z0 + SLAT_T / 2.0),
                     (slat_span, slat_w * 0.92, SLAT_T),
                     WOOD_IDX,
                 )
             )
             y_cursor += slat_w + gap
 
-        back_span = BACK_H - 0.04
+        # Back slats are screwed to the front of the reclined uprights.
+        y_f, z_f = rear[-1 - UPRIGHT_N]
+        y_top, z_top = rear[-1]
+        u = Vector((0.0, y_top - y_f, z_top - z_f))
+        run = u.length
+        u.normalize()
+        fwd = Vector((0.0, -u.z, u.y))
+        base = Vector((0.0, y_f, z_f))
+        d0 = max(0.0, (SEAT_Z + SLAT_T + 0.04 - z_f) / max(u.z, 1e-6))
+        d1 = run - r - BACK_CLEAR
         bwidths = [1.0 + 0.08 * math.sin(i * 1.4 + 0.8) for i in range(N_BACK)]
-        bscale = (back_span - gap * (N_BACK - 1)) / sum(bwidths)
-        z_cursor = SEAT_Z + SLAT_T + 0.04
+        bscale = ((d1 - d0) - gap * (N_BACK - 1)) / sum(bwidths)
+        d_cursor = d0
+        off = r + SLAT_T / 2.0 - SLAT_BITE
         for w in bwidths:
             slat_h = w * bscale
-            z = z_cursor + slat_h * 0.5
+            c = base + u * (d_cursor + slat_h * 0.5) + fwd * off
             wood.extend(
                 add_box(
                     bm,
-                    (0.0, hy, z),
+                    tuple(c),
                     (slat_span, SLAT_T, slat_h * 0.90),
                     WOOD_IDX,
+                    euler=(-recline, 0.0, 0.0),
                 )
             )
-            z_cursor += slat_h + gap
-
+            d_cursor += slat_h + gap
+
+        # Armrests sit on the arm bar, overhang the front leg, and stop a
+        # named tenon inside the reclined upright at their top edge.
+        arm_bot = ARM_Z + r * 0.95 - SLAT_BITE
+        arm_top = arm_bot + SLAT_T
+        y_arm_end = path_y_at(rear, arm_top) - r / math.cos(recline) + ARM_TENON
+        y_arm_0 = -hy - ARM_OVER
         for xsign in (-1.0, 1.0):
-            x = xsign * hx
             wood.extend(
                 add_box(
                     bm,
-                    (x, 0.0, ARM_Z + t * 0.5 + SLAT_T * 0.5),
-                    (SLAT_T * 1.15, 2.0 * hy + t, SLAT_T),
+                    (xsign * hx, 0.5 * (y_arm_0 + y_arm_end), arm_bot + SLAT_T * 0.5),
+                    (SLAT_T * 1.15, y_arm_end - y_arm_0, SLAT_T),
                     WOOD_IDX,
                 )
             )
 
         if bevel_offset > 0.0:
-            edges = list({e for v in wood for e in v.link_edges})
+            # A set of BMEdges iterates in memory order; sort by index so the
+            # bevel lays its faces down in the same order every run.
+            bm.edges.index_update()
+            edges = sorted({e for v in wood for e in v.link_edges}, key=lambda e: e.index)
             ret = bmesh.ops.bevel(
                 bm,
                 geom=edges,
@@ -355,57 +432,59 @@ def build_bench_mesh(
             for f in ret.get("faces") or []:
                 f.material_index = WOOD_IDX
 
-        add_box(bm, (0.0, -hy, SEAT_Z - t * 0.35), (SEAT_SPAN, t, t), METAL_IDX)
-        add_box(bm, (0.0, hy, SEAT_Z - t * 0.35), (SEAT_SPAN, t, t), METAL_IDX)
+        leg_top = arm_bot + LEG_TENON
         for xsign in (-1.0, 1.0):
-            add_box(
+            x = xsign * hx
+            front = toe_arc(-hy, -1.0)
+            if split_feet:
+                # The first build: foot arcs that stop short of the posts,
+                # and posts that start at z=R, as separate shells.
+                add_sweep(bm, [(x, y, z) for y, z in front[:-1]], r, METAL_IDX)
+                add_sweep(bm, [(x, -hy, SCROLL_R), (x, -hy, leg_top)], r, METAL_IDX)
+                add_sweep(bm, [(x, y, z) for y, z in rear[:SCROLL_N]], r, METAL_IDX)
+                add_sweep(bm, [(x, y, z) for y, z in rear[SCROLL_N:]], r, METAL_IDX)
+            else:
+                front.append((-hy, leg_top))
+                add_sweep(bm, [(x, y, z) for y, z in front], r, METAL_IDX)
+                add_sweep(bm, [(x, y, z) for y, z in rear], r, METAL_IDX)
+            add_sweep(
                 bm,
-                (xsign * hx, 0.0, SEAT_Z - t * 0.35),
-                (t, 2.0 * hy, t),
+                [(x, -hy, ARM_Z), (x, path_y_at(rear, ARM_Z), ARM_Z)],
+                r * 0.95,
                 METAL_IDX,
             )
-
-        back_top = SEAT_Z + SLAT_T + BACK_H + 0.02
-        for xsign in (-1.0, 1.0):
-            x = xsign * hx
-            add_oriented_box(
-                bm, (x, hy, SCROLL_R), (x, hy, back_top), (t, t), METAL_IDX
-            )
-            add_oriented_box(
-                bm, (x, -hy, SCROLL_R), (x, -hy, ARM_Z), (t, t), METAL_IDX
-            )
-            add_oriented_box(
-                bm, (x, -hy, ARM_Z), (x, hy, ARM_Z), (t * 0.95, t * 0.95), METAL_IDX
-            )
-            add_foot_scroll(bm, x, -hy, -hy - SCROLL_R, t, METAL_IDX)
-            add_foot_scroll(bm, x, hy, hy + SCROLL_R, t, METAL_IDX)
-            add_arm_scroll(bm, x, -hy, t * 0.90, METAL_IDX)
-
-        add_box(bm, (0.0, hy, back_top), (SEAT_SPAN, t, t), METAL_IDX)
+            # Quarter-round bracket under the armrest's overhang: one end in
+            # the leg, the other up inside the armrest.
+            zc = arm_bot + BRACKET_BITE
+            br = []
+            for i in range(BRACKET_N + 1):
+                a = 1.5 * math.pi - 0.5 * math.pi * i / BRACKET_N
+                br.append((x, -hy + BRACKET_R * math.cos(a), zc + BRACKET_R * math.sin(a)))
+            add_sweep(bm, br, r * 0.85, METAL_IDX)
+            # Side seat rail, leg axis to leg axis.
+            add_sweep(bm, [(x, -hy, rail_z), (x, hy, rail_z)], r, METAL_IDX)
+
+        # Front and back rails stop half a bar inside the legs: ending on the
+        # leg axis puts their end rings on the side rails' end rings.
+        rx = hx - 0.5 * r
+        add_sweep(bm, [(-rx, -hy, rail_z), (rx, -hy, rail_z)], r, METAL_IDX)
+        add_sweep(bm, [(-rx, hy, rail_z), (rx, hy, rail_z)], r, METAL_IDX)
+        # The top rail runs through the upright tops, a heavier bar that
+        # swallows their end caps, out to the armrests' outer faces.
+        tx = hx + SLAT_T * 1.15 * 0.5
+        add_sweep(bm, [(-tx, y_top, z_top), (tx, y_top, z_top)], TOP_RAIL_R, METAL_IDX)
 
         st_trim = FLOAT_STRETCHER if float_stretcher else 0.0
         yx = hx - st_trim
-        add_oriented_box(
-            bm,
-            (-yx, -hy, STRETCHER_Z),
-            (-yx, hy, STRETCHER_Z),
-            (t * 0.9, t * 0.9),
-            METAL_IDX,
-        )
-        add_oriented_box(
-            bm,
-            (yx, -hy, STRETCHER_Z),
-            (yx, hy, STRETCHER_Z),
-            (t * 0.9, t * 0.9),
-            METAL_IDX,
-        )
-        cx_end = yx - t * 0.40
-        add_oriented_box(
-            bm,
-            (-cx_end, 0.0, STRETCHER_Z),
-            (cx_end, 0.0, STRETCHER_Z),
-            (t * 0.9, t * 0.9),
-            METAL_IDX,
+        for xsign in (-1.0, 1.0):
+            add_sweep(
+                bm,
+                [(xsign * yx, -hy, STRETCHER_Z), (xsign * yx, hy, STRETCHER_Z)],
+                r * 0.9,
+                METAL_IDX,
+            )
+        add_sweep(
+            bm, [(-yx, 0.0, STRETCHER_Z), (yx, 0.0, STRETCHER_Z)], r * 0.9, METAL_IDX
         )
 
         if short_feet:
@@ -431,13 +510,12 @@ def build_bench_mesh(
             bmesh.ops.triangulate(bm, faces=ngons)
         pack_uvs(bm)
         bmesh.ops.recalc_face_normals(bm, faces=list(bm.faces))
-        for face in bm.faces:
-            face.smooth = face.material_index == METAL_IDX
         me = bpy.data.meshes.new(name)
         bm.to_mesh(me)
         me.update()
+        # Round bar is smooth-shaded; sawn slats keep their chamfer facets.
         for poly in me.polygons:
-            poly.use_smooth = poly.material_index == METAL_IDX
+            poly.use_smooth = poly.material_index == METAL_IDX and len(poly.vertices) == 4
     finally:
         bm.free()
     out = bpy.data.objects.new(name, me)
@@ -464,9 +542,142 @@ def principled(name, color, metallic, roughness, noise_scale=0.0, wear=None):
         fac = mix.inputs.get("Factor") or mix.inputs.get("Fac")
         nt.links.new(tex.outputs["Fac"], fac)
         nt.links.new(mix.outputs["Result"], bsdf.inputs["Base Color"])
+        rmix = nt.nodes.new("ShaderNodeMix")
+        rmix.data_type = "FLOAT"
+        rmix.inputs["A"].default_value = roughness
+        rmix.inputs["B"].default_value = min(1.0, roughness + 0.18)
+        rfac = rmix.inputs.get("Factor") or rmix.inputs.get("Fac")
+        nt.links.new(tex.outputs["Fac"], rfac)
+        nt.links.new(rmix.outputs["Result"], bsdf.inputs["Roughness"])
+    return mat
+
+
+def _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 slat and armrest is its own shell, so each gets one tone and
+    grain along its own long axis. Iron shells get a tone too; the iron
+    shader ignores it.
+    """
+    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 shells(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 _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 slat (``GrainDir``), tone per slat (``PlankTone``)."""
+    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 bench_materials():
+    """(wood, metal): shared by the check, the render and inspection.
+
+    The first build was one flat brown on every slat and satin iron
+    (metallic 1.0, roughness 0.32) that read as chrome.
+    """
+    wood = wood_material("BenchWood")
+    metal = principled(
+        "BenchIron", (0.040, 0.042, 0.045, 1.0), 0.60, 0.55,
+        noise_scale=18.0, wear=(0.11, 0.055, 0.028, 1.0),
+    )
+    return wood, metal
+
+
 def assign_slots(obj, wood, metal):
     mats = obj.data.materials
     wanted = (wood, metal)
@@ -681,27 +892,75 @@ def add_stray_vert(me):
         bm.free()
 
 
+def shell_bite(me, ga, gb):
+    """Deepest vertex of shell ``ga`` inside closed shell ``gb`` (m); negative if none is."""
+    bm_b = bmesh.new()
+    try:
+        bm_b.from_mesh(me)
+        keep_b = set(gb)
+        drop_b = [f for f in bm_b.faces if not all(v.index in keep_b for v in f.verts)]
+        if drop_b:
+            bmesh.ops.delete(bm_b, geom=drop_b, context="FACES")
+        if not bm_b.faces:
+            return -1e9
+        bmesh.ops.recalc_face_normals(bm_b, faces=list(bm_b.faces))
+        tree = BVHTree.FromBMesh(bm_b)
+        best = -1e9
+        for i in ga:
+            co = me.vertices[i].co
+            loc, nrm, _idx, dist = tree.find_nearest(co)
+            if loc is None:
+                continue
+            depth = dist if (co - loc).dot(nrm) < 0.0 else -dist
+            best = max(best, depth)
+        return best
+    finally:
+        bm_b.free()
+
+
 def joint_audit(me):
     groups = shells(me)
+    owner = {}
+    for gi, g in enumerate(groups):
+        for i in g:
+            owner[i] = gi
+    rail_z = SEAT_Z - IRON_T * 0.35 + BAR_R
+    arm_z = ARM_Z + BAR_R
     posts = []
     stretchers = []
     slats = []
-    for g in groups:
+    seat_slats = []
+    back_slats = []
+    side_rails = []
+    arm_bars = []
+    armrests = []
+    for gi, g in enumerate(groups):
         a = shell_aabb(me, g)
         dx, dy, dz = a[3] - a[0], a[4] - a[1], a[5] - a[2]
+        cz = 0.5 * (a[2] + a[5])
         mat = mat_of(me, g)
-        if mat == METAL_IDX and dz > 0.28 and dx < 0.08 and dy < 0.08:
-            posts.append((g, a))
-        if mat == METAL_IDX and abs(0.5 * (a[2] + a[5]) - STRETCHER_Z) < 0.05 and max(dx, dy) > 0.25:
+        # A leg is one bar from toe to arm (front) or back top (rear); it is
+        # thin across the bench and tall, whatever its depth in plan.
+        if mat == METAL_IDX and dz > 0.28 and dx < 0.08:
+            posts.append((g, a, gi))
+        if mat == METAL_IDX and abs(cz - STRETCHER_Z) < 0.05 and max(dx, dy) > 0.25:
             stretchers.append((g, a))
+        if mat == METAL_IDX and dx < 0.08 and dy > 0.30 and dz < 0.05:
+            if abs(cz - rail_z) < 0.02:
+                side_rails.append((g, a))
+            elif abs(cz - arm_z) < 0.02:
+                arm_bars.append((g, a))
         if mat == WOOD_IDX and dz < 0.08 and dx > SEAT_SPAN * 0.4:
             slats.append((g, a))
+            (seat_slats if cz < SEAT_Z + 0.10 else back_slats).append((g, a))
+        if mat == WOOD_IDX and dx < 0.08 and dy > 0.20:
+            armrests.append((g, a))
     metal_verts = []
     for poly in me.polygons:
         if poly.material_index != METAL_IDX:
             continue
         for i in poly.vertices:
-            metal_verts.append(me.vertices[i].co)
+            metal_verts.append(i)
     stations = (
         (HX, HY + SCROLL_R, 0.0),
         (HX, -HY - SCROLL_R, 0.0),
@@ -710,26 +969,70 @@ def joint_audit(me):
     )
     toes = 0
     toe_z = 99.0
+    leg_ids = {gi for _g, _a, gi in posts}
+    tall = {gi for _g, a, gi in posts if a[5] >= SEAT_Z}
+    continuous = set()
     for sx, sy, sz in stations:
         nearby = []
-        for co in metal_verts:
+        for i in metal_verts:
+            co = me.vertices[i].co
             d = ((co.x - sx) ** 2 + (co.y - sy) ** 2) ** 0.5
             if d < SCROLL_R * 0.55:
-                nearby.append(co)
+                nearby.append(i)
         if nearby:
             toes += 1
-            toe_z = min(toe_z, min(c.z for c in nearby))
+            toe_z = min(toe_z, min(me.vertices[i].co.z for i in nearby))
+            # The toe's own shell must be a leg that reaches the seat: a
+            # foot that is a separate arc under its post fails here.
+            low = min(nearby, key=lambda i: me.vertices[i].co.z)
+            gi = owner[low]
+            if gi in leg_ids and gi in tall:
+                continuous.add(gi)
     st_gap = 99.0
     if stretchers and posts:
         st_gap = min(shell_bvh_gap(me, s[0], p[0]) for s in stretchers for p in posts)
     slat_gap = 99.0
-    rails = [p for p in posts]
-    if slats and rails:
-        slat_gap = min(shell_bvh_gap(me, s[0], p[0]) for s in slats for p in rails)
+    if slats and posts:
+        slat_gap = min(shell_bvh_gap(me, s[0], p[0]) for s in slats for p in posts)
     seat_x = 0.0
     if slats:
         xs = [v for _g, a in slats for v in (a[0], a[3])]
         seat_x = max(xs) - min(xs)
+
+    # Bearing bites: every seat slat is carried by both side rails, every
+    # back slat by both reclined uprights, every armrest by its front leg
+    # and its arm bar. Deepest carrier vertex inside the carried shell.
+    rear = [(g, a) for g, a, _gi in posts if a[5] > ARM_Z + 0.10]
+    front = [(g, a) for g, a, _gi in posts if a[5] <= ARM_Z + 0.10]
+    bites = []
+    # Overlap depth either way round: a rail has vertices only at its ends,
+    # so under a mid-span slat it is the slat's corner that sits in the rail.
+    def overlap(ga, gb):
+        return max(shell_bite(me, ga, gb), shell_bite(me, gb, ga))
+
+    for s, _a in seat_slats:
+        for rl, _b in side_rails:
+            bites.append(("seat", overlap(rl, s)))
+    for s, _a in back_slats:
+        for up, _b in rear:
+            bites.append(("back", overlap(up, s)))
+    for s, a in armrests:
+        side = 0.5 * (a[0] + a[3])
+        for host, b in front + arm_bars:
+            if abs(0.5 * (b[0] + b[3]) - side) < 0.05:
+                bites.append(("arm", overlap(host, s)))
+    bite_min = min((b for _k, b in bites), default=-1.0)
+    bite_kind = min(bites, key=lambda kb: kb[1])[0] if bites else "none"
+
+    # Recline of each rear upright: centroids of a low and a high slab.
+    recl = []
+    for g, a in rear:
+        lo_s = [me.vertices[i].co for i in g if SEAT_Z + 0.16 <= me.vertices[i].co.z <= SEAT_Z + 0.26]
+        hi_s = [me.vertices[i].co for i in g if a[5] - 0.16 <= me.vertices[i].co.z <= a[5] - 0.06]
+        if lo_s and hi_s:
+            c0 = sum(lo_s, Vector()) / len(lo_s)
+            c1 = sum(hi_s, Vector()) / len(hi_s)
+            recl.append(math.degrees(math.atan2(abs(c1.y - c0.y), c1.z - c0.z)))
     return {
         "toes": toes,
         "toe_z": toe_z,
@@ -739,6 +1042,16 @@ def joint_audit(me):
         "slat_gap": slat_gap,
         "seat_x": seat_x,
         "slats": len(slats),
+        "legs_whole": len(continuous),
+        "seat_slats": len(seat_slats),
+        "back_slats": len(back_slats),
+        "side_rails": len(side_rails),
+        "arm_bars": len(arm_bars),
+        "armrests": len(armrests),
+        "bites": len(bites),
+        "bite_min": bite_min,
+        "bite_kind": bite_kind,
+        "recline": recl,
     }
 
 
@@ -802,6 +1115,9 @@ def check(
     gap_slats=False,
     short_feet=False,
     narrow_seat=False,
+    float_slats=False,
+    split_feet=False,
+    upright_back=False,
 ):
     bpy.ops.wm.read_factory_settings(use_empty=True)
     kw = dict(
@@ -809,17 +1125,15 @@ def check(
         gap_slats=gap_slats,
         short_feet=short_feet,
         narrow_seat=narrow_seat,
+        float_slats=float_slats,
+        split_feet=split_feet,
+        upright_back=upright_back,
     )
     low = build_bench_mesh("BenchLow", bevel_offset=0.004, bevel_segments=2, **kw)
     high = build_bench_mesh("BenchHigh", bevel_offset=0.004, bevel_segments=4, **kw)
-    wood = principled(
-        "BenchWood", (0.40, 0.20, 0.07, 1.0), 0.0, 0.58,
-        noise_scale=18.0, wear=(0.28, 0.14, 0.05, 1.0),
-    )
-    metal = principled(
-        "BenchIron", (0.09, 0.095, 0.11, 1.0), 1.0, 0.32,
-        noise_scale=22.0, wear=(0.16, 0.14, 0.10, 1.0),
-    )
+    paint_planks(low.data)
+    paint_planks(high.data)
+    wood, metal = bench_materials()
     assign_slots(low, wood, metal)
     assign_slots(high, wood, metal)
 
@@ -875,6 +1189,9 @@ 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):
+        # Measured; do not leave a .glb per run in the temp directory.
+        os.remove(export_path)
 
     print(f"blender={tuple(bpy.app.version)} skip_decimate={skip_decimate}")
     print(
@@ -907,6 +1224,14 @@ def check(
         f"st_gap={jnt['st_gap']:.5f} slat_gap={jnt['slat_gap']:.5f} "
         f"seat_x={jnt['seat_x']:.4f} slats={jnt['slats']}"
     )
+    recl = jnt["recline"]
+    print(
+        f"measured legs_whole={jnt['legs_whole']} seat_slats={jnt['seat_slats']} "
+        f"back_slats={jnt['back_slats']} side_rails={jnt['side_rails']} "
+        f"arm_bars={jnt['arm_bars']} armrests={jnt['armrests']} "
+        f"bites={jnt['bites']} bite_min={jnt['bite_min']:.5f} ({jnt['bite_kind']}) "
+        f"recline={[round(v, 2) for v in recl]}"
+    )
 
     if not (BASE_TRIS_MIN <= base_tris <= BASE_TRIS_MAX):
         return fail(
@@ -1001,6 +1326,29 @@ def check(
             f"slat gap {jnt['slat_gap']:.5f} slats={jnt['slats']}",
             18,
         ), None, None, None, None, None
+    want_bites = 2 * N_SEAT + 2 * N_BACK + 4
+    if (
+        jnt["seat_slats"] != N_SEAT or jnt["back_slats"] != N_BACK
+        or jnt["side_rails"] != 2 or jnt["arm_bars"] != 2 or jnt["armrests"] != 2
+        or jnt["bites"] != want_bites or jnt["bite_min"] < BITE_MIN
+    ):
+        return fail(
+            f"bearing bite {jnt['bite_min']:.5f} ({jnt['bite_kind']}) < {BITE_MIN} "
+            f"or members seat={jnt['seat_slats']} back={jnt['back_slats']} "
+            f"rails={jnt['side_rails']} bars={jnt['arm_bars']} "
+            f"arms={jnt['armrests']} bites={jnt['bites']}/{want_bites}",
+            20,
+        ), None, None, None, None, None
+    if jnt["legs_whole"] != LEG_COUNT:
+        return fail(
+            f"legs bent in one piece toe to seat {jnt['legs_whole']} != {LEG_COUNT}",
+            21,
+        ), None, None, None, None, None
+    if len(recl) != 2 or not all(RECLINE_MIN_DEG <= v <= RECLINE_MAX_DEG for v in recl):
+        return fail(
+            f"back recline {recl} not in [{RECLINE_MIN_DEG}, {RECLINE_MAX_DEG}] deg",
+            19,
+        ), None, None, None, None, None
     return 0, low, high, wood, tex, collider
 
 
@@ -1021,13 +1369,13 @@ def render_still(low, wood, tex, path, engine):
             ob.hide_render = True
             ob.hide_viewport = True
 
+    # Level on the floor: an X tilt sinks the front toes and lifts the back.
     low.rotation_euler.z = math.radians(-14.0)
-    low.rotation_euler.x = math.radians(2.0)
 
     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()
@@ -1121,6 +1469,9 @@ def main():
     p.add_argument("--float-stretcher", action="store_true")
     p.add_argument("--gap-slats", action="store_true")
     p.add_argument("--narrow-seat", action="store_true")
+    p.add_argument("--float-slats", action="store_true")
+    p.add_argument("--split-feet", action="store_true")
+    p.add_argument("--upright-back", action="store_true")
     args = p.parse_args(argv)
 
     code, low, _high, wood, tex, _col = check(
@@ -1131,6 +1482,9 @@ def main():
         gap_slats=args.gap_slats,
         short_feet=args.short_feet,
         narrow_seat=args.narrow_seat,
+        float_slats=args.float_slats,
+        split_feet=args.split_feet,
+        upright_back=args.upright_back,
     )
     if code:
         return code
diff --git a/showcase/park-bench/preview.webp b/showcase/park-bench/preview.webp
index 443a36fc..a116d798 100644
Binary files a/showcase/park-bench/preview.webp and b/showcase/park-bench/preview.webp differ