diff --git a/docs/gallery/assets/shape-key-blend-hero.webp b/docs/gallery/assets/shape-key-blend-hero.webp
index bcaa60c7..58c1bedb 100644
Binary files a/docs/gallery/assets/shape-key-blend-hero.webp and b/docs/gallery/assets/shape-key-blend-hero.webp differ
diff --git a/docs/gallery/assets/shipping-crate-hero.webp b/docs/gallery/assets/shipping-crate-hero.webp
index 48c80d4f..368a056a 100644
Binary files a/docs/gallery/assets/shipping-crate-hero.webp and b/docs/gallery/assets/shipping-crate-hero.webp differ
diff --git a/docs/gallery/contact-sheets/shape-key-blend-contact-sheet.webp b/docs/gallery/contact-sheets/shape-key-blend-contact-sheet.webp
new file mode 100644
index 00000000..fbd1315a
Binary files /dev/null and b/docs/gallery/contact-sheets/shape-key-blend-contact-sheet.webp differ
diff --git a/docs/gallery/contact-sheets/shipping-crate-contact-sheet.webp b/docs/gallery/contact-sheets/shipping-crate-contact-sheet.webp
index 4350dd54..85199f8b 100644
Binary files a/docs/gallery/contact-sheets/shipping-crate-contact-sheet.webp and b/docs/gallery/contact-sheets/shipping-crate-contact-sheet.webp differ
diff --git a/docs/gallery/index.html b/docs/gallery/index.html
index 0d622708..d5b8fb6c 100644
--- a/docs/gallery/index.html
+++ b/docs/gallery/index.html
@@ -464,7 +464,7 @@ <h2><a href="gn-modifier-inputs/">gn-modifier-inputs</a></h2>
       </article>
       <article class="card" data-tags="mesh shape-keys">
         <a class="card-media" href="shape-key-blend/" tabindex="-1" aria-hidden="true">
-          <img src="assets/shape-key-blend-hero.webp" alt="Three purple boxes flaring wider at the top by increasing amounts, from a plain cube to a strong flare." loading="lazy" decoding="async" />
+          <img src="assets/shape-key-blend-hero.webp" alt="Three purple boxes flaring wider at the top by increasing amounts; the rightmost sits inside a pale wire cage of its full shape key, halfway to it." loading="lazy" decoding="async" />
         </a>
         <div class="card-body">
           <h2><a href="shape-key-blend/">shape-key-blend</a></h2>
@@ -904,7 +904,7 @@ <h2><a href="gn-socket-rename/">gn-socket-rename</a></h2>
       </article>
       <article class="card" data-tags="mesh export showcase">
         <a class="card-media" href="shipping-crate/" tabindex="-1" aria-hidden="true">
-          <img src="assets/shipping-crate-hero.webp" alt="A wooden shipping crate with dark corner posts, horizontal planks and a metal handle." loading="lazy" decoding="async" />
+          <img src="assets/shipping-crate-hero.webp" alt="A grained wooden shipping crate with nailed iron corner straps, horizontal planks and a metal bail handle mounted on one end board." loading="lazy" decoding="async" />
         </a>
         <div class="card-body">
           <h2><a href="shipping-crate/">shipping-crate</a></h2>
diff --git a/docs/gallery/shape-key-blend/index.html b/docs/gallery/shape-key-blend/index.html
index eba301c0..abdb0a41 100644
--- a/docs/gallery/shape-key-blend/index.html
+++ b/docs/gallery/shape-key-blend/index.html
@@ -16,13 +16,13 @@
   <meta property="og:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/shape-key-blend-hero.webp" />
   <meta property="og:image:width" content="1280" />
   <meta property="og:image:height" content="720" />
-  <meta property="og:image:alt" content="Three purple boxes flaring wider at the top by increasing amounts, from a plain cube to a strong flare." />
+  <meta property="og:image:alt" content="Three purple boxes flaring wider at the top by increasing amounts; the rightmost sits inside a pale wire cage of its full shape key, halfway to it." />
   <meta property="og:site_name" content="Blender Developer Tools" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="shape-key-blend — Examples — Blender Developer Tools" />
   <meta name="twitter:description" content="A relative Tall shape key that lifts and flares the top face — authored via shape_key_add / key_blocks / .value — read back from the depsgraph-evaluated mesh." />
   <meta name="twitter:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/shape-key-blend-hero.webp" />
-  <meta name="twitter:image:alt" content="Three purple boxes flaring wider at the top by increasing amounts, from a plain cube to a strong flare." />
+  <meta name="twitter:image:alt" content="Three purple boxes flaring wider at the top by increasing amounts; the rightmost sits inside a pale wire cage of its full shape key, halfway to it." />
   <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>shape-key-blend</h1>
     <p>A relative Tall shape key that lifts and flares the top face — authored via shape_key_add / key_blocks / .value — read back from the depsgraph-evaluated mesh.</p>
   </header>
   <main id="main">
-    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: Three purple boxes flaring wider at the top by increasing amounts, from a plain cube to a strong flare.">
-      <img src="../assets/shape-key-blend-hero.webp" alt="Three purple boxes flaring wider at the top by increasing amounts, from a plain cube to a strong flare." width="1280" height="720" />
+    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: Three purple boxes flaring wider at the top by increasing amounts; the rightmost sits inside a pale wire cage of its full shape key, halfway to it.">
+      <img src="../assets/shape-key-blend-hero.webp" alt="Three purple boxes flaring wider at the top by increasing amounts; the rightmost sits inside a pale wire cage of its full shape key, halfway to it." 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> Shape keys do not rewrite mesh.vertices: every evaluated vert matches basis + value × (key − basis), including the flared top half-extent.</div>
@@ -460,6 +460,30 @@ <h2>Source</h2>
         ob.rotation_euler = (<span class="n">0.0</span>, <span class="n">0.0</span>, math.radians(<span class="n">28</span>))
         blocks.append(ob)
 
+    <span class="c"># Endpoint cages on the checked block: its Basis and its full Tall key as</span>
+    <span class="c"># pale wireframes, so the solid visibly sits halfway between the two —</span>
+    <span class="c"># the closed-form blend the check asserts, not just &quot;a taller box&quot;.</span>
+    <span class="c"># Render-only copies with their own key value; `obj` is untouched.</span>
+    cage_mat = bpy.data.materials.new(<span class="s">&quot;Cage&quot;</span>)
+    cage_mat.use_nodes = <span class="k">True</span>
+    cbsdf = cage_mat.node_tree.nodes[<span class="s">&quot;Principled BSDF&quot;</span>]
+    cbsdf.inputs[<span class="s">&quot;Base Color&quot;</span>].default_value = (<span class="n">0.92</span>, <span class="n">0.84</span>, <span class="n">1.0</span>, <span class="n">1.0</span>)
+    cbsdf.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.4</span>
+    cages = []
+    <span class="k">for</span> end <span class="k">in</span> (<span class="n">0.0</span>, <span class="n">1.0</span>):
+        me = obj.data.copy()
+        me.materials.clear()
+        me.materials.append(cage_mat)
+        me.shape_keys.key_blocks[<span class="s">&quot;Tall&quot;</span>].value = end
+        cage = bpy.data.objects.new(<span class="s">f&quot;</span><span class="s">Cage_</span>{end}<span class="s">&quot;</span>, me)
+        cage.location = obj.location
+        cage.rotation_euler = obj.rotation_euler
+        wire = cage.modifiers.new(<span class="s">&quot;cage&quot;</span>, <span class="s">&quot;WIREFRAME&quot;</span>)
+        wire.thickness = <span class="n">0.02</span>
+        wire.use_even_offset = <span class="k">True</span>
+        bpy.context.collection.objects.link(cage)
+        cages.append(cage)
+
     floor_me = bpy.data.meshes.new(<span class="s">&quot;Floor&quot;</span>)
     bm = bmesh.new()
     <span class="k">try</span>:
@@ -487,7 +511,9 @@ <h2>Source</h2>
 
     world_top = HALF + EXPECT_TOP_Z
     aim = bpy.data.objects.new(<span class="s">&quot;Aim&quot;</span>, <span class="k">None</span>)
-    aim.location = (<span class="n">0.0</span>, <span class="n">0.0</span>, world_top / <span class="n">2</span>)
+    <span class="c"># Aimed above the checked block&#x27;s middle: the full-key cage over it is</span>
+    <span class="c"># taller than any solid, and centring on the solids clipped it.</span>
+    aim.location = (<span class="n">0.35</span>, <span class="n">0.0</span>, world_top * <span class="n">0.62</span>)
     scene.collection.objects.link(aim)
 
     <span class="k">def</span> light(name, loc, energy, size, col):
@@ -520,7 +546,8 @@ <h2>Source</h2>
     cam_data = bpy.data.cameras.new(<span class="s">&quot;Cam&quot;</span>)
     cam_data.lens = <span class="n">50.0</span>
     cam = bpy.data.objects.new(<span class="s">&quot;Cam&quot;</span>, cam_data)
-    cam.location = (<span class="n">0.0</span>, -<span class="n">8.8</span>, <span class="n">2.05</span>)
+    <span class="c"># Pulled back so the full-key cage on the right block stays in frame.</span>
+    cam.location = (<span class="n">0.35</span>, -<span class="n">10.4</span>, <span class="n">2.5</span>)
     scene.collection.objects.link(cam)
     scene.camera = cam
     track = cam.constraints.new(<span class="s">&#x27;TRACK_TO&#x27;</span>)
@@ -581,7 +608,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/shape-key-blend-hero.webp" alt="Three purple boxes flaring wider at the top by increasing amounts, from a plain cube to a strong flare." />
+    <img src="../assets/shape-key-blend-hero.webp" alt="Three purple boxes flaring wider at the top by increasing amounts; the rightmost sits inside a pale wire cage of its full shape key, halfway to it." />
   </dialog>
   <footer>
     <div class="statusbar">
diff --git a/docs/gallery/shipping-crate/index.html b/docs/gallery/shipping-crate/index.html
index 1e10a902..1b01a9aa 100644
--- a/docs/gallery/shipping-crate/index.html
+++ b/docs/gallery/shipping-crate/index.html
@@ -16,13 +16,13 @@
   <meta property="og:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/shipping-crate-hero.webp" />
   <meta property="og:image:width" content="1280" />
   <meta property="og:image:height" content="720" />
-  <meta property="og:image:alt" content="A wooden shipping crate with dark corner posts, horizontal planks and a metal handle." />
+  <meta property="og:image:alt" content="A grained wooden shipping crate with nailed iron corner straps, horizontal planks and a metal bail handle mounted on one end board." />
   <meta property="og:site_name" content="Blender Developer Tools" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="shipping-crate — Showcase — Blender Developer Tools" />
   <meta name="twitter:description" content="A procedural shipping crate 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/shipping-crate-hero.webp" />
-  <meta name="twitter:image:alt" content="A wooden shipping crate with dark corner posts, horizontal planks and a metal handle." />
+  <meta name="twitter:image:alt" content="A grained wooden shipping crate with nailed iron corner straps, horizontal planks and a metal bail handle mounted on one end board." />
   <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>shipping-crate</h1>
     <p>A procedural shipping crate 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 wooden shipping crate with dark corner posts, horizontal planks and a metal handle.">
-      <img src="../assets/shipping-crate-hero.webp" alt="A wooden shipping crate with dark corner posts, horizontal planks and a metal handle." width="1280" height="720" />
+    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: A grained wooden shipping crate with nailed iron corner straps, horizontal planks and a metal bail handle mounted on one end board.">
+      <img src="../assets/shipping-crate-hero.webp" alt="A grained wooden shipping crate with nailed iron corner straps, horizontal planks and a metal bail handle mounted on one end board." 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: 2508 tris, two materials with 1170 wood and 280 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 1.146×0.726×0.612 m, grounded zmin, 3 skids, handle-end and slat-post join 0, mesh hygiene all zero, LOD ratios in band (5.2 COLLAPSE leaner on LOD2), convex collider 76 tris, non-empty glTF. --skip-decimate exits 9; --stray-vert 15; --lift-z/--short-skids 16; --float-handle 17; --omit-slats 18.</div>
@@ -278,23 +278,27 @@ <h1>shipping-crate</h1>
       <button class="copy-btn" id="copyRun" type="button">Copy</button>
     </div>
     <section class="detail-section md">
-<p>A showcase piece, not an example. Procedural crate (skids under the posts, corner posts with tenoned slats and seeded width jitter, bottom sills, L-straps, filleted iron bail handles through mounting plates) then the shipped pipeline: unique-cell UVs, Cycles high-to-low normal bake, LOD chain, convex collider, Unity glTF export.</p>
+<p>A showcase piece, not an example. Procedural crate (skids under the posts, corner posts with tenoned slats and seeded width jitter, bottom sills, nailed single-shell L-straps, filleted iron bail handles through mounting plates seated on one end board each) then the shipped pipeline: unique-cell UVs, Cycles high-to-low normal bake, LOD chain, convex collider, Unity glTF export.</p>
 <p>Skids sit under the posts so the outer corner is a mortise, not a cave. Handle bails use quarter-circle corners so a 90-degree loft cannot sit the bar on the plate.</p>
 <p>It asserts <strong>budget conformance</strong> of the generated result. It does not witness an API contract. &quot;It rendered without error&quot; is not a check.</p>
 <p><strong>Composes</strong> skills <code>mesh-editing-and-bmesh</code>, <code>bake-high-to-low</code>, <code>depsgraph-and-evaluated-data</code>, <code>engine-export-presets</code>, and snippets <code>bake_normal_high_to_low.py</code>, <code>setup_bake_target_image.py</code>, <code>lod_chain.py</code> / <code>decimate_to_budget.py</code>, <code>convex_hull_collider.py</code>, <code>export_preset_unity.py</code> (helpers copied, not imported as a package).</p>
 <h2>Budgets</h2>
 <p>Declared as named constants; every gate <strong>recomputes</strong> from the mesh, materials, UVs, evaluated LOD, collider, or export file.</p>
-<div class="table-wrap"><table><thead><tr><th scope="col">Axis</th><th scope="col">Declared</th><th scope="col">Measured (4.5.11 / 5.1.2 / 5.2.1)</th></tr></thead><tbody><tr><td>Base triangles</td><td>1200–2800</td><td>2508 / 2508 / 2508</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.2193 / 0.2193 / 0.2057</td></tr><tr><td>Materials</td><td>exactly 2 distinct; ≥200 wood, ≥48 metal faces</td><td>2 slots; 1170 / 280</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.146, 0.726, 0.612) m ± 0.015</td><td>(1.1460, 0.7260, 0.6120), zmin 0</td></tr><tr><td>Collider tris</td><td>≤ 220</td><td>76</td></tr><tr><td>Export</td><td>written, size &gt; 0</td><td>197408 / 197408 / 197392 bytes</td></tr></tbody></table></div>
-<p>Base triangles rose from <strong>624 to 2508</strong> in the quality pass: the old beveled cube with glued-on slats became a post-and-slat crate with tenons, sills, L-straps, and pipe handles.</p>
-<p>DECIMATE COLLAPSE triangle counts are <strong>not</strong> identical across series — 5.2.1 is leaner on LOD2. The gate is a ratio band, not an exact count. Bake pixels are stochastic; the gate is <code>has_data</code> plus operator <code>FINISHED</code>, not byte-identity. Slat-width jitter uses fixed seed 17. Export byte counts differ by 16 B on 5.2.1 (glTF serializer), not a gated axis.</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–3900</td><td>3388 / 3388 / 3388</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.2196 / 0.2196 / 0.2196</td></tr><tr><td>Materials</td><td>exactly 2 distinct; ≥900 wood, ≥600 metal faces</td><td>2 slots; 1170 / 904</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.146, 0.726, 0.612) m ± 0.015</td><td>(1.1460, 0.7260, 0.6120), zmin 0</td></tr><tr><td>Collider tris</td><td>≤ 220</td><td>116</td></tr><tr><td>Export</td><td>written, size &gt; 0</td><td>273816 / 273816 / 273800 bytes</td></tr></tbody></table></div>
+<p>Base triangles rose from <strong>624 to 2508</strong> in the quality pass: the old beveled cube with glued-on slats became a post-and-slat crate with tenons, sills, L-straps, and pipe handles. The second pass took them to <strong>3388</strong>: single-shell chamfered straps, 24 nails, chamfered mounting plates.</p>
+<p>DECIMATE COLLAPSE triangle counts are <strong>not</strong> guaranteed identical across series; on this mesh they happen to match (LOD2 744 on all three). 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. Slat-width jitter uses fixed seed 17. Export byte counts differ by 16 B on 5.2.1 (glTF serializer), not a gated axis.</p>
 <h3>Hygiene</h3>
 <p>Recomputed from the generated mesh, not asserted about the script.</p>
 <div class="table-wrap"><table><thead><tr><th scope="col">Axis</th><th scope="col">Declared</th><th scope="col">Measured (all three)</th></tr></thead><tbody><tr><td>Non-manifold edges</td><td>0</td><td>0</td></tr><tr><td>Loose verts / edges</td><td>0 / 0</td><td>0 / 0</td></tr><tr><td>Doubles merged at 1e-5</td><td>0</td><td>0</td></tr><tr><td>Zero-area faces</td><td>0</td><td>0</td></tr><tr><td>N-gons</td><td>0</td><td>0</td></tr><tr><td>Coplanar disjoint face pairs</td><td>0</td><td>0</td></tr><tr><td>Grounded: <code>zmin</code></td><td>within 1e-4 of 0</td><td>0.0000</td></tr><tr><td>Named supports: 3 skids</td><td>each <code>zmin</code> ≤ 1e-3</td><td>3, skid_z 0.00000</td></tr><tr><td>Body plan</td><td>1.056 × 0.716 m ± 0.05</td><td>1.0560 × 0.7160</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>Handle-end BVH gap</td><td>≤ 0.008 m</td><td>0.00000</td></tr><tr><td>Slat-post BVH gap</td><td>≤ 0.006 m</td><td>0.00000</td></tr></tbody></table></div>
+<div class="table-wrap"><table><thead><tr><th scope="col">Axis</th><th scope="col">Declared</th><th scope="col">Measured (all three)</th></tr></thead><tbody><tr><td>Handle-end BVH gap</td><td>≤ 0.008 m</td><td>0.00000</td></tr><tr><td>Slat-post BVH gap</td><td>≤ 0.006 m</td><td>0.00000</td></tr><tr><td>Nail seat</td><td>24 nails; bite 0.3–1.0 mm into the strap, head ≥ 1.0 mm proud</td><td>24; 0.60 mm; 1.80 mm</td></tr><tr><td>Handle plates on one board</td><td>each plate inside a single end board with ≥ 4 mm clearance at both edges</td><td>4 plates; 32.4 mm</td></tr></tbody></table></div>
+<h3>Second pass (straps, nails, handle placement, surface)</h3>
+<p>The inspection sheet found the iron and the handles built the way <code>crate-stack</code> used to build them:</p>
+<ul><li><strong>Straps were two unbevelled boxes per corner.</strong> That left a seam line down the outer corner, razor edges, and an inner face sitting flush on the post face. Each strap is now one L-section extrusion that bites <code>IRON_BITE</code> into the post. It is chamfered at <code>IRON_BEVEL</code> with <code>material=METAL_IDX</code>, since bevel otherwise hands chamfer faces slot 0. Code copied from <code>crate-stack</code>, not imported.</li><li><strong>No fasteners.</strong> Three nail stations per plate, 24 nails, placed from each plate&#x27;s own outer face and normal. <code>nail_audit</code> asserts the seat band (exit 18, <code>--float-nails</code>).</li><li><strong>The handle mounting plates straddled the gap between two end boards.</strong> The handle sat at a fixed 52% of post height, which landed on a gap. It now snaps to the centre of the end board nearest that height, from the same <code>_span_layout</code> the boards come from. <code>plate_board_audit</code> asserts each plate sits inside one board with clearance at both edges (exit 20, <code>--straddle-handle</code>, which puts the handle on a gap and measures −26.9 mm).</li><li><strong>Every plank was the same flat tone.</strong> <code>PlankTone</code> / <code>GrainDir</code> face attributes drive a grain-along-the-board wood shader. The iron gets rust wear.</li><li>The temp glTF export is removed after it is measured.</li></ul>
+<p>The right-angle-edge budget from <code>crate-stack</code> is not applied here: the handle bail&#x27;s pipe ends are square discs buried in the mounting plates, so &quot;every box is chamfered&quot; does not hold for this piece.</p>
 <h3>Falsifiers</h3>
-<p>Each violates one named budget. All seven were run on 4.5.11, 5.1.2 and 5.2.1 and returned the same code on each.</p>
-<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-skids</code></td><td>named skid supports at Z=0</td><td>16</td></tr><tr><td><code>--float-handle</code></td><td>handle-end gap</td><td>17</td></tr><tr><td><code>--omit-slats</code></td><td>slat-post seat</td><td>18</td></tr></tbody></table></div>
+<p>Each violates one named budget. All nine were run on 4.5.11, 5.1.2 and 5.2.1 and returned the same code on each.</p>
+<div class="table-wrap"><table><thead><tr><th scope="col">Flag</th><th scope="col">Budget violated</th><th scope="col">Exit</th></tr></thead><tbody><tr><td><code>--skip-decimate</code></td><td>LOD1 ratio band</td><td>9</td></tr><tr><td><code>--stray-vert</code></td><td>loose vertex count is 0</td><td>15</td></tr><tr><td><code>--lift-z</code></td><td>bounding box <code>zmin</code> is 0</td><td>16</td></tr><tr><td><code>--short-skids</code></td><td>named skid supports at Z=0</td><td>16</td></tr><tr><td><code>--float-handle</code></td><td>handle-end gap</td><td>17</td></tr><tr><td><code>--omit-slats</code></td><td>slat-post seat</td><td>18</td></tr><tr><td><code>--float-nails</code></td><td>nail seat band (heads lifted 1.5 mm off the straps)</td><td>18</td></tr><tr><td><code>--straddle-handle</code></td><td>handle plates on one end board</td><td>20</td></tr></tbody></table></div>
 <h2>Run</h2>
 <pre><code>blender --background --python shipping_crate.py --
 blender --background --python shipping_crate.py -- --skip-decimate
@@ -303,11 +307,13 @@ <h2>Run</h2>
 blender --background --python shipping_crate.py -- --short-skids
 blender --background --python shipping_crate.py -- --float-handle
 blender --background --python shipping_crate.py -- --omit-slats
+blender --background --python shipping_crate.py -- --float-nails
+blender --background --python shipping_crate.py -- --straddle-handle
 blender --background --python shipping_crate.py -- --output crate.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 a face-count floor missed</td></tr><tr><td>6</td><td>UVs outside 0..1</td></tr><tr><td>7</td><td>UV AABB overlap above tolerance</td></tr><tr><td>8</td><td>World AABB off declared outer size</td></tr><tr><td>9</td><td>LOD ratio band (<code>--skip-decimate</code> lands here)</td></tr><tr><td>10</td><td>Framing gate (render path only)</td></tr><tr><td>11</td><td>Collider triangle count above ceiling</td></tr><tr><td>12</td><td>Bake did not finish or image has no data</td></tr><tr><td>13</td><td>Export file missing or empty</td></tr><tr><td>14</td><td><code>--output</code> produced no file</td></tr><tr><td>15</td><td>Mesh hygiene: loose, non-manifold, zero-area, doubles, n-gons, z-fight</td></tr><tr><td>16</td><td>Not grounded: bounding box <code>zmin</code> off 0, or a named skid floats</td></tr><tr><td>17</td><td>Joint fit: handle-end gap</td></tr><tr><td>18</td><td>Seat: slat-post gap</td></tr><tr><td>19</td><td>Body plan off the stated real-world size</td></tr></tbody></table></div>
+<div class="table-wrap"><table><thead><tr><th scope="col">Code</th><th scope="col">Meaning</th></tr></thead><tbody><tr><td>0</td><td>Success</td></tr><tr><td>1</td><td>Uncaught exception (FATAL wrapper)</td></tr><tr><td>2</td><td>argparse / usage</td></tr><tr><td>3</td><td>Mesh did not build / no UV layer</td></tr><tr><td>4</td><td>Base triangle count outside range</td></tr><tr><td>5</td><td>Material count ≠ 2 distinct slots, or a face-count floor missed</td></tr><tr><td>6</td><td>UVs outside 0..1</td></tr><tr><td>7</td><td>UV AABB overlap above tolerance</td></tr><tr><td>8</td><td>World AABB off declared outer size</td></tr><tr><td>9</td><td>LOD ratio band (<code>--skip-decimate</code> lands here)</td></tr><tr><td>10</td><td>Framing gate (render path only)</td></tr><tr><td>11</td><td>Collider triangle count above ceiling</td></tr><tr><td>12</td><td>Bake did not finish or image has no data</td></tr><tr><td>13</td><td>Export file missing or empty</td></tr><tr><td>14</td><td><code>--output</code> produced no file</td></tr><tr><td>15</td><td>Mesh hygiene: loose, non-manifold, zero-area, doubles, n-gons, z-fight</td></tr><tr><td>16</td><td>Not grounded: bounding box <code>zmin</code> off 0, or a named skid floats</td></tr><tr><td>17</td><td>Joint fit: handle-end gap</td></tr><tr><td>18</td><td>Seat: slat-post gap, or a nail head off its strap seat band (<code>--float-nails</code>)</td></tr><tr><td>19</td><td>Body plan off the stated real-world size</td></tr><tr><td>20</td><td>A handle mounting plate not seated on a single end board (<code>--straddle-handle</code>)</td></tr></tbody></table></div>
     </section>
     <section class="detail-section src">
       <h2>Source</h2>
@@ -318,7 +324,8 @@ <h2>Source</h2>
       <pre><span class="s">&quot;&quot;&quot;Game-ready shipping crate — a showcase piece, not an example.
 
 Asserts budget conformance of a procedural crate (skids, corner posts,
-tenoned slats with seeded width jitter, L-straps, iron bail handles)
+tenoned slats with seeded width jitter, nailed single-shell L-straps,
+iron bail handles on one end board each)
 after composing shipped pipeline pieces: bmesh construction, UVs, two
 materials, high-to-low normal bake, LOD chain, convex collider, Unity
 glTF export.
@@ -332,9 +339,10 @@ <h2>Source</h2>
 budget: ``--skip-decimate`` the LOD-ratio band, ``--stray-vert`` mesh
 hygiene, ``--lift-z`` grounded zmin, ``--short-skids`` named skid
 supports, ``--float-handle`` handle-to-end joint-fit, ``--omit-slats``
-slat-to-post seat.
+slat-to-post seat, ``--float-nails`` nail seat, ``--straddle-handle``
+handle plates on one board.
 
-Fixed seed 17 for slat-width jitter. DECIMATE COLLAPSE triangle counts
+Fixed seed 17 for slat-width jitter, 29 for plank tone. DECIMATE COLLAPSE triangle counts
 are not byte-identical across Blender versions — the LOD gate is a
 ratio band, not an exact count.
 
@@ -352,7 +360,7 @@ <h2>Source</h2>
 
 <span class="k">import</span> bmesh
 <span class="k">import</span> bpy
-<span class="k">from</span> mathutils <span class="k">import</span> Vector
+<span class="k">from</span> mathutils <span class="k">import</span> Matrix, Vector
 <span class="k">from</span> mathutils.bvhtree <span class="k">import</span> BVHTree
 
 _REPO = os.path.abspath(
@@ -387,8 +395,8 @@ <h2>Source</h2>
 BODY_X, BODY_Y, BODY_Z = <span class="n">1.056</span>, <span class="n">0.716</span>, <span class="n">0.576</span>
 BODY_TOL = <span class="n">0.05</span>
 
-BASE_TRIS_MIN = <span class="n">1200</span>
-BASE_TRIS_MAX = <span class="n">2800</span>
+BASE_TRIS_MIN = <span class="n">2900</span>
+BASE_TRIS_MAX = <span class="n">3900</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>
@@ -401,8 +409,8 @@ <h2>Source</h2>
 COLLIDER_TRIS_MAX = <span class="n">220</span>
 BAKE_RES = <span class="n">256</span>
 CAGE_EXTRUSION = <span class="n">0.08</span>
-METAL_FACES_MIN = <span class="n">48</span>
-WOOD_FACES_MIN = <span class="n">200</span>
+METAL_FACES_MIN = <span class="n">600</span>
+WOOD_FACES_MIN = <span class="n">900</span>
 ZMIN_EPS = <span class="n">1e-4</span>
 DOUBLES_EPS = <span class="n">1e-5</span>
 AREA_EPS = <span class="n">1e-10</span>
@@ -416,6 +424,30 @@ <h2>Source</h2>
 WOOD_IDX = <span class="n">0</span>
 METAL_IDX = <span class="n">1</span>
 
+<span class="c"># Straps bite into the post rather than sitting flush on it: a flush plate</span>
+<span class="c"># puts its inner face on the post&#x27;s outer face, one plane shared by two</span>
+<span class="c"># shells. Chamfered at their own fine offset, a single L-section shell each.</span>
+IRON_BITE = <span class="n">0.0012</span>
+IRON_BEVEL = <span class="n">0.0008</span>
+<span class="c"># Clout nails through each strap into the post, seated a named bite deep.</span>
+NAIL_R = <span class="n">0.0050</span>
+NAIL_R_TOP = <span class="n">0.0036</span>
+NAIL_H = <span class="n">0.0024</span>
+NAIL_BITE = <span class="n">0.0006</span>
+NAIL_SEGS = <span class="n">6</span>
+NAIL_ZS = (<span class="n">0.12</span>, <span class="n">0.50</span>, <span class="n">0.88</span>)
+NAIL_BITE_MIN = <span class="n">0.0003</span>
+NAIL_BITE_MAX = <span class="n">0.0010</span>
+NAIL_PROUD_MIN = <span class="n">0.0010</span>
+NAIL_EXTENT_MAX = IRON_WRAP * <span class="n">0.5</span>
+N_NAILS = <span class="n">4</span> * <span class="n">2</span> * len(NAIL_ZS)
+FLOAT_NAIL_LIFT = <span class="n">0.0015</span>
+<span class="c"># Handle mounting plates must sit on one end board, clear of both edges.</span>
+PLATE_H = <span class="n">0.044</span>
+PLATE_BOARD_MARGIN = <span class="n">0.004</span>
+PLANK_TONE_JITTER = <span class="n">0.28</span>
+TONE_SEED = <span class="n">29</span>
+
 
 <span class="k">def</span> eevee_engine_id():
     <span class="s">&quot;&quot;&quot;EEVEE id: &#x27;BLENDER_EEVEE&#x27; on 5.0+, &#x27;BLENDER_EEVEE_NEXT&#x27; on 4.2-4.5.
@@ -613,6 +645,8 @@ <h2>Source</h2>
     short_skids=<span class="k">False</span>,
     float_handle=<span class="k">False</span>,
     omit_slats=<span class="k">False</span>,
+    float_nails=<span class="k">False</span>,
+    straddle_handle=<span class="k">False</span>,
 ):
     ix, iy, iz = INNER
     hx = ix / <span class="n">2.0</span> + POST / <span class="n">2.0</span>
@@ -744,6 +778,7 @@ <h2>Source</h2>
                         )
                     )
         end_c, end_w = _span_layout(N_END, iz - <span class="n">0.04</span>, rng)
+        end_z0 = SKID_H + <span class="n">0.02</span> + iz / <span class="n">2.0</span>
         <span class="k">for</span> sign <span class="k">in</span> (-<span class="n">1.0</span>, <span class="n">1.0</span>):
             x = sign * (ix / <span class="n">2.0</span> + POST - SLAT_T / <span class="n">2.0</span> - <span class="n">0.001</span>)
             <span class="k">for</span> c, w <span class="k">in</span> zip(end_c, end_w):
@@ -769,43 +804,46 @@ <h2>Source</h2>
                     clamp_overlap=<span class="k">True</span>,
                 )
 
-        <span class="c"># L-straps: two plates meeting at a vertical edge, proud of the</span>
-        <span class="c"># post. Not three overlapping cubes — those leave window holes.</span>
-        wrap = IRON_WRAP
+        <span class="c"># L-straps: one extruded L-section shell per corner, biting into the</span>
+        <span class="c"># post. Two boxes put a seam down the outer corner and, flush on</span>
+        <span class="c"># the post, shared the post&#x27;s face plane.</span>
         strap_z0 = <span class="n">0.006</span>
         strap_h = top_z - strap_z0
-        zc = strap_z0 + strap_h / <span class="n">2.0</span>
+        px = hx + POST / <span class="n">2.0</span> + IRON_T - IRON_BITE
+        py = hy + POST / <span class="n">2.0</span> + IRON_T - IRON_BITE
+        iron = []
         <span class="k">for</span> sxn <span class="k">in</span> (-<span class="n">1.0</span>, <span class="n">1.0</span>):
             <span class="k">for</span> syn <span class="k">in</span> (-<span class="n">1.0</span>, <span class="n">1.0</span>):
-                ox = sxn * (hx + POST / <span class="n">2.0</span> + IRON_T / <span class="n">2.0</span>)
-                oy = syn * (hy + POST / <span class="n">2.0</span> + IRON_T / <span class="n">2.0</span>)
-                add_box(
-                    bm,
-                    (ox, syn * (hy + POST / <span class="n">2.0</span> - wrap / <span class="n">2.0</span> + IRON_T / <span class="n">2.0</span>), zc),
-                    (IRON_T, wrap, strap_h),
-                    METAL_IDX,
-                )
-                add_box(
-                    bm,
-                    (sxn * (hx + POST / <span class="n">2.0</span> - wrap / <span class="n">2.0</span> + IRON_T / <span class="n">2.0</span>), oy, zc),
-                    (wrap - IRON_T, IRON_T, strap_h),
-                    METAL_IDX,
-                )
-
-        hz = SKID_H + post_h * <span class="n">0.52</span>
+                iron.extend(add_strap(bm, sxn, syn, px, py, strap_z0, strap_h))
+                <span class="k">for</span> fz <span class="k">in</span> NAIL_ZS:
+                    z = strap_z0 + strap_h * fz
+                    add_nail(bm, Vector((sxn * px, syn * (py - IRON_WRAP * <span class="n">0.5</span>), z)),
+                             Vector((sxn, <span class="n">0.0</span>, <span class="n">0.0</span>)), float_nails)
+                    add_nail(bm, Vector((sxn * (px - IRON_WRAP * <span class="n">0.5</span>), syn * py, z)),
+                             Vector((<span class="n">0.0</span>, syn, <span class="n">0.0</span>)), float_nails)
+
+        <span class="c"># The handle rides on the end board nearest mid-height, centred on</span>
+        <span class="c"># it, so its mounting plates are screwed to wood, not to a gap.</span>
+        <span class="c"># --straddle-handle puts it on the gap between two boards instead.</span>
+        want = SKID_H + post_h * <span class="n">0.52</span>
+        k = min(range(N_END), key=<span class="k">lambda</span> i: abs(end_z0 + end_c[i] - want))
+        hz = end_z0 + end_c[k]
+        <span class="k">if</span> straddle_handle:
+            j = k + <span class="n">1</span> <span class="k">if</span> k + <span class="n">1</span> &lt; N_END <span class="k">else</span> k - <span class="n">1</span>
+            hz = end_z0 + <span class="n">0.5</span> * (end_c[k] + end_c[j])
         <span class="k">for</span> sxn <span class="k">in</span> (-<span class="n">1.0</span>, <span class="n">1.0</span>):
             x_plate = sxn * (ix / <span class="n">2.0</span> + POST - SLAT_T / <span class="n">2.0</span>)
             x_in = sxn * (ix / <span class="n">2.0</span> + POST - SLAT_T - <span class="n">0.008</span>)
             x_out = sxn * (ix / <span class="n">2.0</span> + POST + HANDLE_OUT)
             y0, y1 = -<span class="n">0.11</span>, <span class="n">0.11</span>
-            add_box(
+            iron.extend(add_box(
                 bm, (x_plate, y0, hz),
-                (SLAT_T + IRON_T * <span class="n">2.0</span>, <span class="n">0.034</span>, <span class="n">0.044</span>), METAL_IDX,
-            )
-            add_box(
+                (SLAT_T + IRON_T * <span class="n">2.0</span>, <span class="n">0.034</span>, PLATE_H), METAL_IDX,
+            ))
+            iron.extend(add_box(
                 bm, (x_plate, y1, hz),
-                (SLAT_T + IRON_T * <span class="n">2.0</span>, <span class="n">0.034</span>, <span class="n">0.044</span>), METAL_IDX,
-            )
+                (SLAT_T + IRON_T * <span class="n">2.0</span>, <span class="n">0.034</span>, PLATE_H), METAL_IDX,
+            ))
             <span class="k">if</span> float_handle:
                 add_box(
                     bm, (x_out, <span class="n">0.0</span>, hz), (<span class="n">0.020</span>, <span class="n">0.020</span>, <span class="n">0.020</span>), METAL_IDX,
@@ -815,6 +853,19 @@ <h2>Source</h2>
                     bm, x_in, x_out, y0, y1, hz, HANDLE_R, <span class="n">8</span>, METAL_IDX,
                 )
 
+        <span class="c"># Chamfer the straps and mounting plates at their own offset; the</span>
+        <span class="c"># flat diagonal inside each L cap is not a corner. material= keeps</span>
+        <span class="c"># the chamfer faces iron (bevel otherwise hands them slot 0).</span>
+        iron_edges = [
+            e <span class="k">for</span> e <span class="k">in</span> {e <span class="k">for</span> v <span class="k">in</span> iron <span class="k">if</span> v.is_valid <span class="k">for</span> e <span class="k">in</span> v.link_edges}
+            <span class="k">if</span> len(e.link_faces) == <span class="n">2</span> <span class="k">and</span> e.calc_face_angle(<span class="n">0.0</span>) &gt; <span class="n">1e-3</span>
+        ]
+        <span class="k">if</span> iron_edges:
+            bmesh.ops.bevel(
+                bm, geom=iron_edges, offset=IRON_BEVEL, segments=<span class="n">1</span>, profile=<span class="n">0.5</span>,
+                affect=<span class="s">&quot;EDGES&quot;</span>, clamp_overlap=<span class="k">True</span>, material=METAL_IDX,
+            )
+
         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:
@@ -829,11 +880,175 @@ <h2>Source</h2>
         me.update()
     <span class="k">finally</span>:
         bm.free()
+    paint_planks(me)
     obj = bpy.data.objects.new(name, me)
     bpy.context.collection.objects.link(obj)
     <span class="k">return</span> obj
 
 
+<span class="k">def</span> add_strap(bm, sxn, syn, px, py, z0, h):
+    <span class="s">&quot;&quot;&quot;One L-section corner strap as a single closed shell (copied from crate-stack).
+
+    Each cap is two convex quads meeting on the inner-corner diagonal, so
+    there is no n-gon; the bottom cap is wound opposite the top.
+    &quot;&quot;&quot;</span>
+    outline = [
+        (px, py - IRON_WRAP),
+        (px, py),
+        (px - IRON_WRAP, py),
+        (px - IRON_WRAP, py - IRON_T),
+        (px - IRON_T, py - IRON_T),
+        (px - IRON_T, py - IRON_WRAP),
+    ]
+    rings = [[bm.verts.new((sxn * x, syn * y, z)) <span class="k">for</span> x, y <span class="k">in</span> outline] <span class="k">for</span> z <span class="k">in</span> (z0, z0 + h)]
+    lo, hi = rings
+    faces = []
+    <span class="k">for</span> ring, flip <span class="k">in</span> ((lo, <span class="k">True</span>), (hi, <span class="k">False</span>)):
+        <span class="k">for</span> quad <span class="k">in</span> ((<span class="n">0</span>, <span class="n">1</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">4</span>)):
+            vs = [ring[k] <span class="k">for</span> k <span class="k">in</span> quad]
+            faces.append(bm.faces.new(vs[::-<span class="n">1</span>] <span class="k">if</span> flip <span class="k">else</span> vs))
+    <span class="k">for</span> i <span class="k">in</span> range(len(outline)):
+        j = (i + <span class="n">1</span>) % len(outline)
+        faces.append(bm.faces.new((lo[i], lo[j], hi[j], hi[i])))
+    <span class="k">for</span> f <span class="k">in</span> faces:
+        f.material_index = METAL_IDX
+    <span class="k">return</span> lo + hi
+
+
+<span class="k">def</span> add_nail(bm, face_pt, nrm, lift=<span class="k">False</span>):
+    <span class="s">&quot;&quot;&quot;A frustum nail head seated NAIL_BITE into the plate at *face_pt*.&quot;&quot;&quot;</span>
+    geo = bmesh.ops.create_cone(
+        bm, cap_ends=<span class="k">True</span>, cap_tris=<span class="k">True</span>, segments=NAIL_SEGS,
+        radius1=NAIL_R, radius2=NAIL_R_TOP, depth=NAIL_H,
+    )
+    orient = nrm.to_track_quat(<span class="s">&quot;Z&quot;</span>, <span class="s">&quot;Y&quot;</span>).to_matrix().to_4x4()
+    up = FLOAT_NAIL_LIFT <span class="k">if</span> lift <span class="k">else</span> <span class="n">0.0</span>
+    seat = Matrix.Translation(face_pt + nrm * up) @ orient @ Matrix.Translation(
+        (<span class="n">0.0</span>, <span class="n">0.0</span>, NAIL_H / <span class="n">2.0</span> - NAIL_BITE)
+    )
+    <span class="k">for</span> v <span class="k">in</span> geo[<span class="s">&quot;verts&quot;</span>]:
+        v.co = seat @ v.co
+    <span class="k">for</span> f <span class="k">in</span> {f <span class="k">for</span> v <span class="k">in</span> geo[<span class="s">&quot;verts&quot;</span>] <span class="k">for</span> f <span class="k">in</span> v.link_faces}:
+        f.material_index = METAL_IDX
+
+
+<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.&quot;&quot;&quot;</span>
+    tone = [<span class="n">0.5</span>] * len(me.polygons)
+    grain = [(<span class="n">1.0</span>, <span class="n">0.0</span>, <span class="n">0.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">1.0</span>, <span class="n">0.0</span>, <span class="n">0.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 board (``GrainDir``), tone per board (``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 = <span class="n">30.0</span>
+    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> crate_materials():
+    <span class="s">&quot;&quot;&quot;(wood, iron): shared by the check, the render and inspection.&quot;&quot;&quot;</span>
+    wood = wood_material(<span class="s">&quot;CrateWood&quot;</span>)
+    metal = principled(
+        <span class="s">&quot;CrateMetal&quot;</span>, (<span class="n">0.17</span>, <span class="n">0.165</span>, <span class="n">0.155</span>, <span class="n">1.0</span>), <span class="n">0.80</span>, <span class="n">0.46</span>,
+        noise_scale=<span class="n">18.0</span>, wear=(<span class="n">0.20</span>, <span class="n">0.085</span>, <span class="n">0.032</span>, <span class="n">1.0</span>),
+    )
+    <span class="k">return</span> wood, metal
+
+
 <span class="k">def</span> principled(name, color, metallic, roughness, noise_scale=<span class="n">0.0</span>, wear=<span class="k">None</span>):
     mat = bpy.data.materials.new(name)
     mat.use_nodes = <span class="k">True</span>
@@ -1116,6 +1331,72 @@ <h2>Source</h2>
     <span class="k">return</span> _bvh_gap(me, posts, slats)
 
 
+<span class="k">def</span> nail_audit(me):
+    <span class="s">&quot;&quot;&quot;Seat of every nail head in its strap (copied from crate-stack).
+
+    Nails are the small iron shells; every other iron shell is a host.
+    Signed distance to the host surface per nail vertex: the deepest is
+    the bite (banded), the highest is how proud the head stands.
+    &quot;&quot;&quot;</span>
+    nails, hosts = [], []
+    <span class="k">for</span> g <span class="k">in</span> shells(me):
+        <span class="k">if</span> mat_of(me, g) != METAL_IDX:
+            <span class="k">continue</span>
+        a = shell_aabb(me, g)
+        ext = max(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>])
+        (nails <span class="k">if</span> ext &lt; NAIL_EXTENT_MAX <span class="k">else</span> hosts).append(g)
+    <span class="k">if</span> <span class="k">not</span> nails <span class="k">or</span> <span class="k">not</span> hosts:
+        <span class="k">return</span> {<span class="s">&quot;n&quot;</span>: len(nails), <span class="s">&quot;bite_min&quot;</span>: <span class="n">0.0</span>, <span class="s">&quot;bite_max&quot;</span>: <span class="n">0.0</span>, <span class="s">&quot;proud_min&quot;</span>: <span class="n">0.0</span>}
+    bm = bmesh.new()
+    <span class="k">try</span>:
+        bm.from_mesh(me)
+        keep = {i <span class="k">for</span> g <span class="k">in</span> hosts <span class="k">for</span> i <span class="k">in</span> g}
+        drop = [f <span class="k">for</span> f <span class="k">in</span> bm.faces <span class="k">if</span> <span class="k">not</span> all(v.index <span class="k">in</span> keep <span class="k">for</span> v <span class="k">in</span> f.verts)]
+        bmesh.ops.delete(bm, geom=drop, context=<span class="s">&quot;FACES&quot;</span>)
+        tree = BVHTree.FromBMesh(bm)
+    <span class="k">finally</span>:
+        bm.free()
+    bites, prouds = [], []
+    <span class="k">for</span> g <span class="k">in</span> nails:
+        signed = []
+        <span class="k">for</span> i <span class="k">in</span> g:
+            co = me.vertices[i].co
+            loc, nrm, _idx, _d = tree.find_nearest(co)
+            signed.append(<span class="n">99.0</span> <span class="k">if</span> loc <span class="k">is</span> <span class="k">None</span> <span class="k">else</span> (co - loc).dot(nrm))
+        bites.append(-min(signed))
+        prouds.append(max(signed))
+    <span class="k">return</span> {<span class="s">&quot;n&quot;</span>: len(nails), <span class="s">&quot;bite_min&quot;</span>: min(bites), <span class="s">&quot;bite_max&quot;</span>: max(bites),
+            <span class="s">&quot;proud_min&quot;</span>: min(prouds)}
+
+
+<span class="k">def</span> plate_board_audit(me):
+    <span class="s">&quot;&quot;&quot;Worst clearance of a handle mounting plate inside a single end board.
+
+    End boards are the thin wood shells standing across an end of the
+    crate; mounting plates are the iron shells PLATE_H tall. For each plate
+    the clearance is how far its z-range sits inside the best-fitting
+    board&#x27;s z-range, at both edges. Negative means the plate hangs over a
+    board edge, onto the gap.
+    &quot;&quot;&quot;</span>
+    boards, plates = [], []
+    <span class="k">for</span> g <span class="k">in</span> shells(me):
+        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>]
+        m = mat_of(me, g)
+        <span class="k">if</span> m == WOOD_IDX <span class="k">and</span> dx &lt; SLAT_T * <span class="n">2.5</span> <span class="k">and</span> dy &gt; INNER[<span class="n">1</span>] * <span class="n">0.8</span> <span class="k">and</span> dz &lt; INNER[<span class="n">2</span>] * <span class="n">0.5</span>:
+            boards.append(a)
+        <span class="k">elif</span> m == METAL_IDX <span class="k">and</span> abs(dz - PLATE_H) &lt; <span class="n">0.004</span> <span class="k">and</span> dy &lt; <span class="n">0.05</span>:
+            plates.append(a)
+    worst = <span class="n">99.0</span>
+    <span class="k">for</span> pa <span class="k">in</span> plates:
+        side = [b <span class="k">for</span> b <span class="k">in</span> boards <span class="k">if</span> abs(<span class="n">0.5</span> * (b[<span class="n">0</span>] + b[<span class="n">3</span>]) - <span class="n">0.5</span> * (pa[<span class="n">0</span>] + pa[<span class="n">3</span>])) &lt; <span class="n">0.05</span>]
+        best = max(
+            (min(pa[<span class="n">2</span>] - b[<span class="n">2</span>], b[<span class="n">5</span>] - pa[<span class="n">5</span>]) <span class="k">for</span> b <span class="k">in</span> side), default=-<span class="n">99.0</span>
+        )
+        worst = min(worst, best)
+    <span class="k">return</span> {<span class="s">&quot;plates&quot;</span>: len(plates), <span class="s">&quot;boards&quot;</span>: len(boards), <span class="s">&quot;clear&quot;</span>: worst}
+
+
 <span class="k">def</span> add_stray_vert(me):
     bm = bmesh.new()
     <span class="k">try</span>:
@@ -1222,23 +1503,20 @@ <h2>Source</h2>
     short_skids=<span class="k">False</span>,
     float_handle=<span class="k">False</span>,
     omit_slats=<span class="k">False</span>,
+    float_nails=<span class="k">False</span>,
+    straddle_handle=<span class="k">False</span>,
 ):
     bpy.ops.wm.read_factory_settings(use_empty=<span class="k">True</span>)
     flags = dict(
         short_skids=short_skids,
         float_handle=float_handle,
         omit_slats=omit_slats,
+        float_nails=float_nails,
+        straddle_handle=straddle_handle,
     )
     low = build_crate_mesh(<span class="s">&quot;CrateLow&quot;</span>, **flags)
     high = build_crate_mesh(<span class="s">&quot;CrateHigh&quot;</span>, **flags)
-    wood = principled(
-        <span class="s">&quot;CrateWood&quot;</span>, (<span class="n">0.48</span>, <span class="n">0.22</span>, <span class="n">0.07</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.50</span>,
-        noise_scale=<span class="n">7.0</span>, wear=(<span class="n">0.28</span>, <span class="n">0.14</span>, <span class="n">0.05</span>, <span class="n">1.0</span>),
-    )
-    metal = principled(
-        <span class="s">&quot;CrateMetal&quot;</span>, (<span class="n">0.18</span>, <span class="n">0.17</span>, <span class="n">0.16</span>, <span class="n">1.0</span>), <span class="n">0.86</span>, <span class="n">0.36</span>,
-        noise_scale=<span class="n">5.0</span>, wear=(<span class="n">0.10</span>, <span class="n">0.09</span>, <span class="n">0.08</span>, <span class="n">1.0</span>),
-    )
+    wood, metal = crate_materials()
     assign_slots(low, wood, metal)
     assign_slots(high, wood, metal)
     <span class="k">if</span> stray_vert:
@@ -1292,6 +1570,10 @@ <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="c"># Blender points TMPDIR at its own temp preference, which on a portable</span>
+    <span class="c"># build is the working directory, so the export must not outlive this.</span>
+    <span class="k">if</span> os.path.isfile(export_path):
+        os.remove(export_path)
 
     hyg = hygiene_audit(low.data)
     zf = zfight_pairs(low.data)
@@ -1299,6 +1581,8 @@ <h2>Source</h2>
     body = body_audit(low.data)
     hj = handle_join(low.data)
     sj = slat_join(low.data)
+    nails = nail_audit(low.data)
+    pb = plate_board_audit(low.data)
 
     print(<span class="s">f&quot;</span><span class="s">blender=</span>{tuple(bpy.app.version)}<span class="s"> skip_decimate=</span>{skip_decimate}<span class="s">&quot;</span>)
     print(
@@ -1327,6 +1611,11 @@ <h2>Source</h2>
         <span class="s">f&quot;</span><span class="s">body=(</span>{body[<span class="s">&#x27;dx&#x27;</span>]:<span class="s">.4f</span>}<span class="s">,</span>{body[<span class="s">&#x27;dy&#x27;</span>]:<span class="s">.4f</span>}<span class="s">,</span>{body[<span class="s">&#x27;dz&#x27;</span>]:<span class="s">.4f</span>}<span class="s">) </span><span class="s">&quot;</span>
         <span class="s">f&quot;</span><span class="s">handle_join=</span>{hj:<span class="s">.5f</span>}<span class="s"> slat_join=</span>{sj:<span class="s">.5f</span>}<span class="s">&quot;</span>
     )
+    print(
+        <span class="s">f&quot;</span><span class="s">measured nails n=</span>{nails[<span class="s">&#x27;n&#x27;</span>]}<span class="s"> bite=[</span>{nails[<span class="s">&#x27;bite_min&#x27;</span>]:<span class="s">.5f</span>}<span class="s">, </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span>{nails[<span class="s">&#x27;bite_max&#x27;</span>]:<span class="s">.5f</span>}<span class="s">] proud_min=</span>{nails[<span class="s">&#x27;proud_min&#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">plates=</span>{pb[<span class="s">&#x27;plates&#x27;</span>]}<span class="s"> boards=</span>{pb[<span class="s">&#x27;boards&#x27;</span>]}<span class="s"> plate_clear=</span>{pb[<span class="s">&#x27;clear&#x27;</span>]:<span class="s">.5f</span>}<span class="s">&quot;</span>
+    )
 
     <span class="k">if</span> <span class="k">not</span> (BASE_TRIS_MIN &lt;= base_tris &lt;= BASE_TRIS_MAX):
         <span class="k">return</span> fail(
@@ -1425,10 +1714,31 @@ <h2>Source</h2>
             <span class="s">&quot;(--omit-slats is the designed fail)&quot;</span>,
             <span class="n">18</span>,
         ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+    <span class="k">if</span> (
+        nails[<span class="s">&quot;n&quot;</span>] != N_NAILS
+        <span class="k">or</span> nails[<span class="s">&quot;bite_min&quot;</span>] &lt; NAIL_BITE_MIN
+        <span class="k">or</span> nails[<span class="s">&quot;bite_max&quot;</span>] &gt; NAIL_BITE_MAX
+        <span class="k">or</span> nails[<span class="s">&quot;proud_min&quot;</span>] &lt; NAIL_PROUD_MIN
+    ):
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">nail seat: </span>{nails[<span class="s">&#x27;n&#x27;</span>]}<span class="s"> of </span>{N_NAILS}<span class="s"> nails, bite </span><span class="s">&quot;</span>
+            <span class="s">f&quot;</span><span class="s">[</span>{nails[<span class="s">&#x27;bite_min&#x27;</span>]:<span class="s">.5f</span>}<span class="s">, </span>{nails[<span class="s">&#x27;bite_max&#x27;</span>]:<span class="s">.5f</span>}<span class="s">] outside </span><span class="s">&quot;</span>
+            <span class="s">f&quot;</span><span class="s">[</span>{NAIL_BITE_MIN}<span class="s">, </span>{NAIL_BITE_MAX}<span class="s">] or proud </span><span class="s">&quot;</span>
+            <span class="s">f&quot;</span>{nails[<span class="s">&#x27;proud_min&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> &lt; </span>{NAIL_PROUD_MIN}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">&quot;(--float-nails is the designed fail)&quot;</span>,
+            <span class="n">18</span>,
+        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
     <span class="k">if</span> abs(body[<span class="s">&quot;dx&quot;</span>] - BODY_X) &gt; BODY_TOL:
         <span class="k">return</span> fail(<span class="s">f&quot;</span><span class="s">body dx </span>{body[<span class="s">&#x27;dx&#x27;</span>]:<span class="s">.4f</span>}<span class="s"> off </span>{BODY_X}<span class="s">&quot;</span>, <span class="n">19</span>), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
     <span class="k">if</span> abs(body[<span class="s">&quot;dy&quot;</span>] - BODY_Y) &gt; BODY_TOL:
         <span class="k">return</span> fail(<span class="s">f&quot;</span><span class="s">body dy </span>{body[<span class="s">&#x27;dy&#x27;</span>]:<span class="s">.4f</span>}<span class="s"> off </span>{BODY_Y}<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> pb[<span class="s">&quot;plates&quot;</span>] != <span class="n">4</span> <span class="k">or</span> pb[<span class="s">&quot;clear&quot;</span>] &lt; PLATE_BOARD_MARGIN:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">handle plates </span>{pb[<span class="s">&#x27;plates&#x27;</span>]}<span class="s"> clear of board edges by </span><span class="s">&quot;</span>
+            <span class="s">f&quot;</span>{pb[<span class="s">&#x27;clear&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> &lt; </span>{PLATE_BOARD_MARGIN}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">&quot;(--straddle-handle is the designed fail)&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">return</span> <span class="n">0</span>, low, high, wood, tex, collider
 
 
@@ -1548,6 +1858,8 @@ <h2>Source</h2>
     p.add_argument(<span class="s">&quot;--short-skids&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
     p.add_argument(<span class="s">&quot;--float-handle&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
     p.add_argument(<span class="s">&quot;--omit-slats&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--float-nails&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--straddle-handle&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
     args = p.parse_args(argv)
 
     code, low, _high, wood, tex, _col = check(
@@ -1557,6 +1869,8 @@ <h2>Source</h2>
         short_skids=args.short_skids,
         float_handle=args.float_handle,
         omit_slats=args.omit_slats,
+        float_nails=args.float_nails,
+        straddle_handle=args.straddle_handle,
     )
     <span class="k">if</span> code:
         <span class="k">return</span> code
@@ -1581,7 +1895,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/shipping-crate-hero.webp" alt="A wooden shipping crate with dark corner posts, horizontal planks and a metal handle." />
+    <img src="../assets/shipping-crate-hero.webp" alt="A grained wooden shipping crate with nailed iron corner straps, horizontal planks and a metal bail handle mounted on one end board." />
   </dialog>
   <footer>
     <div class="statusbar">
diff --git a/examples/gallery.json b/examples/gallery.json
index 379297d1..b9a58fbf 100644
--- a/examples/gallery.json
+++ b/examples/gallery.json
@@ -152,7 +152,7 @@
       "name": "shape-key-blend",
       "dir": "examples/shape-key-blend",
       "teaches": "A relative Tall shape key that lifts and flares the top face — authored via shape_key_add / key_blocks / .value — read back from the depsgraph-evaluated mesh.",
-      "alt": "Three purple boxes flaring wider at the top by increasing amounts, from a plain cube to a strong flare.",
+      "alt": "Three purple boxes flaring wider at the top by increasing amounts; the rightmost sits inside a pale wire cage of its full shape key, halfway to it.",
       "witnessesFix": "Shape keys do not rewrite mesh.vertices: every evaluated vert matches basis + value × (key − basis), including the flared top half-extent.",
       "hero": "docs/gallery/assets/shape-key-blend-hero.webp",
       "preview": "examples/shape-key-blend/preview.webp",
diff --git a/examples/shape-key-blend/preview.webp b/examples/shape-key-blend/preview.webp
index e043ea0b..3b93d3bd 100644
Binary files a/examples/shape-key-blend/preview.webp and b/examples/shape-key-blend/preview.webp differ
diff --git a/examples/shape-key-blend/shape_key_blend.py b/examples/shape-key-blend/shape_key_blend.py
index 35fdd5c9..5e72729c 100644
--- a/examples/shape-key-blend/shape_key_blend.py
+++ b/examples/shape-key-blend/shape_key_blend.py
@@ -157,6 +157,30 @@ def render_still(obj, path, engine):
         ob.rotation_euler = (0.0, 0.0, math.radians(28))
         blocks.append(ob)
 
+    # Endpoint cages on the checked block: its Basis and its full Tall key as
+    # pale wireframes, so the solid visibly sits halfway between the two —
+    # the closed-form blend the check asserts, not just "a taller box".
+    # Render-only copies with their own key value; `obj` is untouched.
+    cage_mat = bpy.data.materials.new("Cage")
+    cage_mat.use_nodes = True
+    cbsdf = cage_mat.node_tree.nodes["Principled BSDF"]
+    cbsdf.inputs["Base Color"].default_value = (0.92, 0.84, 1.0, 1.0)
+    cbsdf.inputs["Roughness"].default_value = 0.4
+    cages = []
+    for end in (0.0, 1.0):
+        me = obj.data.copy()
+        me.materials.clear()
+        me.materials.append(cage_mat)
+        me.shape_keys.key_blocks["Tall"].value = end
+        cage = bpy.data.objects.new(f"Cage_{end}", me)
+        cage.location = obj.location
+        cage.rotation_euler = obj.rotation_euler
+        wire = cage.modifiers.new("cage", "WIREFRAME")
+        wire.thickness = 0.02
+        wire.use_even_offset = True
+        bpy.context.collection.objects.link(cage)
+        cages.append(cage)
+
     floor_me = bpy.data.meshes.new("Floor")
     bm = bmesh.new()
     try:
@@ -184,7 +208,9 @@ def render_still(obj, path, engine):
 
     world_top = HALF + EXPECT_TOP_Z
     aim = bpy.data.objects.new("Aim", None)
-    aim.location = (0.0, 0.0, world_top / 2)
+    # Aimed above the checked block's middle: the full-key cage over it is
+    # taller than any solid, and centring on the solids clipped it.
+    aim.location = (0.35, 0.0, world_top * 0.62)
     scene.collection.objects.link(aim)
 
     def light(name, loc, energy, size, col):
@@ -217,7 +243,8 @@ def light(name, loc, energy, size, col):
     cam_data = bpy.data.cameras.new("Cam")
     cam_data.lens = 50.0
     cam = bpy.data.objects.new("Cam", cam_data)
-    cam.location = (0.0, -8.8, 2.05)
+    # Pulled back so the full-key cage on the right block stays in frame.
+    cam.location = (0.35, -10.4, 2.5)
     scene.collection.objects.link(cam)
     scene.camera = cam
     track = cam.constraints.new('TRACK_TO')
diff --git a/examples/vse-linear-modifiers/README.md b/examples/vse-linear-modifiers/README.md
index b34973b5..d2674677 100644
--- a/examples/vse-linear-modifiers/README.md
+++ b/examples/vse-linear-modifiers/README.md
@@ -1,6 +1,6 @@
 # VSE linear modifiers attribute
 
-Pathology witness for the 5.2 removal of `Sequence.use_linear_modifiers`.
+Pathology witness for the 5.2 removal of `Strip.use_linear_modifiers`.
 A COLOR strip is enough; there is no geometry and **no gallery still**
 (same class as [`exit-pre-sidecar`](../exit-pre-sidecar/),
 [`ngon-triangulate`](../ngon-triangulate/)).
@@ -14,10 +14,17 @@ version-gated assertion shape of
 does **not** version-branch — `del` is the same on 4.5 and 5.x — so the
 gate itself is copied from `gn-modifier-inputs`, not from `del`.
 
-**What it witnesses:** `ColorStrip.use_linear_modifiers` is a bool you can
-set on 4.5.11 and 5.1.2. The same getattr/setattr is `AttributeError` on
+**What it witnesses:** `use_linear_modifiers` is a bool you can set on a
+strip on 4.5.11 and 5.1.2. The same getattr/setattr is `AttributeError` on
 5.2.1. `hasattr` then read never raises on any of the three.
 
+**The identifier is `Strip`, not `Sequence`.** Earlier text here named
+`Sequence.use_linear_modifiers`. `bpy.types.Sequence` does not exist on
+4.5.11, 5.1.2 or 5.2.1. The strip types are `Strip` / `ColorStrip`, and
+the attribute is defined on the `Strip` base (the class chain is
+`ColorStrip → EffectStrip → Strip`), so every strip type had it. Anyone
+searching the API docs for `Sequence` will not find it.
+
 **What failure each check would catch:**
 
 - exit 3 — COLOR strip never landed
@@ -34,6 +41,52 @@ binary.
 
 No `SMOKE_SKIP`. Every matrix leg exercises the contract.
 
+## Who hits this
+
+Add-ons, presets and conform scripts that set
+`strip.use_linear_modifiers = True` so colour-balance and curve modifiers
+work in linear space. On 5.2 that line raises
+`AttributeError: 'ColorStrip' object has no attribute 'use_linear_modifiers'`
+(or the matching strip type), and the script stops at the first strip.
+The RNA description on 4.5 and 5.1 reads:
+
+> Calculate modifiers in linear space instead of sequencer's space
+
+The default is `False` on both. On 5.2.1 there is no replacement
+property: no identifier containing `linear` exists on `Strip` or on the
+strip modifier (`COLOR_BALANCE` listed as a representative). Guard the
+write with `hasattr`, as `guarded_read` does for the read. This example
+does not claim how 5.2 chooses the colour space for strip modifiers; it
+measures only that the switch is gone from RNA.
+
+## Re-verified
+
+| Measurement | 4.5.11 | 5.1.2 | 5.2.1 |
+| --- | --- | --- | --- |
+| `bpy.types.Sequence` exists | no | no | no |
+| Attribute defined on | `Strip` | `Strip` | — (removed) |
+| Default | `False` | `False` | — |
+| `linear`-named property on `Strip` / strip modifier | yes / no | yes / — | no / no |
+| default exit | 0 | 0 | 0 |
+| `--assume-present` exit | 0 | 0 | 4 |
+
+Exiting 0 on 4.5.11 and 5.1.2 under the falsifier is correct by design.
+The attribute exists there, so the naive read works; the falsifier
+exists to fail where it was removed.
+
+**Observed while re-verifying, outside this contract:** on 5.1.2 in
+background mode, `strip.modifiers.new(name=..., type="COLOR_BALANCE")` on
+a COLOR strip created in factory-empty crashes Blender with
+`EXCEPTION_ACCESS_VIOLATION`. The same call works on 4.5.11 and 5.2.1.
+This example never adds a modifier, so its checks are unaffected.
+
+## API reference
+
+- [`bpy.types.Strip`](https://docs.blender.org/api/current/bpy.types.Strip.html)
+  ([4.5 LTS](https://docs.blender.org/api/4.5/bpy.types.Strip.html#bpy.types.Strip.use_linear_modifiers),
+  where `use_linear_modifiers` is documented)
+- [`bpy.types.StripModifier`](https://docs.blender.org/api/current/bpy.types.StripModifier.html)
+
 ## Run
 
 ```bash
diff --git a/examples/vse-linear-modifiers/vse_linear_modifiers.py b/examples/vse-linear-modifiers/vse_linear_modifiers.py
index d51651f6..f0d19b80 100644
--- a/examples/vse-linear-modifiers/vse_linear_modifiers.py
+++ b/examples/vse-linear-modifiers/vse_linear_modifiers.py
@@ -1,6 +1,8 @@
 """VSE strip.use_linear_modifiers removal — a runnable example.
 
-Witnesses the 5.2 removal of ``Sequence.use_linear_modifiers``. Access is a
+Witnesses the 5.2 removal of ``Strip.use_linear_modifiers`` (the RNA
+type is ``Strip`` on every targeted version; ``bpy.types.Sequence`` does
+not exist on 4.5, 5.1 or 5.2). Access is a
 bool on 4.5 LTS and 5.1; the same getattr/setattr raises AttributeError on
 5.2. Version-guarded code (``hasattr`` then read) does not raise on any of
 the three. Pathology: no geometry, no gallery still.
diff --git a/showcase/README.md b/showcase/README.md
index dfb3083a..f2f1f9a9 100644
--- a/showcase/README.md
+++ b/showcase/README.md
@@ -55,6 +55,8 @@ entry in `showcase/gallery.json`, and a rendered still.
   `--open-ends` restores open U-band ends so the water is not contained
   (exit 18). `--pile-rocks` draws scattered stones together so they
   interpenetrate (file-local code; `terrain-scatter` uses 20).
+  `--straddle-handle` mounts a fixture across a board gap (file-local
+  code; `shipping-crate` uses 20).
   `--sharp-iron` skips a chamfer pass so the edge-treatment budget fails
   (file-local code; `crate-stack` uses 21).
   A budget with no falsifier witnesses nothing:
@@ -359,6 +361,14 @@ entry in `showcase/gallery.json`, and a rendered still.
   A falsifier that only skips the relaxation proves nothing if the parts
   happen to miss anyway; `terrain-scatter`'s `--pile-rocks` also draws
   the scatter inward so collisions are guaranteed.
+- **A fixture is mounted on a member, not across a gap (file-local
+  code).** Handles, hinges, hasps and plates screwed to planked faces
+  must land on one board. A height fixed as a fraction of the frame lands
+  wherever the plank layout happens to put a gap: `shipping-crate`'s
+  handle plates sat across the slot between two end boards. Snap the
+  fixture to the centre of the nearest board, from the same layout
+  function that places the boards, and assert each mounting plate sits
+  inside a single board's extent with a named clearance at both edges.
 - **Rock is broken, not smooth.** A smooth-shaded ellipsoid is an egg.
   Cleave it with a few closed-form planes (project every vertex beyond a
   plane onto it) and shade it flat, so it reads as broken stone. Cleaving
diff --git a/showcase/gallery.json b/showcase/gallery.json
index 3fb97d46..531b64fc 100644
--- a/showcase/gallery.json
+++ b/showcase/gallery.json
@@ -9,7 +9,7 @@
       "name": "shipping-crate",
       "dir": "showcase/shipping-crate",
       "teaches": "A procedural shipping crate through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.",
-      "alt": "A wooden shipping crate with dark corner posts, horizontal planks and a metal handle.",
+      "alt": "A grained wooden shipping crate with nailed iron corner straps, horizontal planks and a metal bail handle mounted on one end board.",
       "witnessesFix": "Recomputed: 2508 tris, two materials with 1170 wood and 280 metal faces, UVs in 0..1 with zero AABB overlap, outer AABB 1.146×0.726×0.612 m, grounded zmin, 3 skids, handle-end and slat-post join 0, mesh hygiene all zero, LOD ratios in band (5.2 COLLAPSE leaner on LOD2), convex collider 76 tris, non-empty glTF. --skip-decimate exits 9; --stray-vert 15; --lift-z/--short-skids 16; --float-handle 17; --omit-slats 18.",
       "hero": "docs/gallery/assets/shipping-crate-hero.webp",
       "preview": "showcase/shipping-crate/preview.webp",
diff --git a/showcase/shipping-crate/README.md b/showcase/shipping-crate/README.md
index 5fc61eac..79771bbd 100644
--- a/showcase/shipping-crate/README.md
+++ b/showcase/shipping-crate/README.md
@@ -2,7 +2,8 @@
 
 A showcase piece, not an example. Procedural crate (skids under the
 posts, corner posts with tenoned slats and seeded width jitter, bottom
-sills, L-straps, filleted iron bail handles through mounting plates)
+sills, nailed single-shell L-straps, filleted iron bail handles through
+mounting plates seated on one end board each)
 then the shipped pipeline: unique-cell UVs, Cycles high-to-low normal
 bake, LOD chain, convex collider, Unity glTF export.
 
@@ -26,21 +27,23 @@ materials, UVs, evaluated LOD, collider, or export file.
 
 | Axis | Declared | Measured (4.5.11 / 5.1.2 / 5.2.1) |
 | --- | --- | --- |
-| Base triangles | 1200–2800 | 2508 / 2508 / 2508 |
+| Base triangles | 2900–3900 | 3388 / 3388 / 3388 |
 | LOD1 ratio | 0.32–0.62 of base | 0.5000 / 0.5000 / 0.5000 |
-| LOD2 ratio | 0.10–0.35 of base | 0.2193 / 0.2193 / 0.2057 |
-| Materials | exactly 2 distinct; ≥200 wood, ≥48 metal faces | 2 slots; 1170 / 280 |
+| LOD2 ratio | 0.10–0.35 of base | 0.2196 / 0.2196 / 0.2196 |
+| Materials | exactly 2 distinct; ≥900 wood, ≥600 metal faces | 2 slots; 1170 / 904 |
 | UVs | in `0..1`, AABB overlap ≤ 1e-5 | in range, overlap 0 |
 | Outer AABB | (1.146, 0.726, 0.612) m ± 0.015 | (1.1460, 0.7260, 0.6120), zmin 0 |
-| Collider tris | ≤ 220 | 76 |
-| Export | written, size > 0 | 197408 / 197408 / 197392 bytes |
+| Collider tris | ≤ 220 | 116 |
+| Export | written, size > 0 | 273816 / 273816 / 273800 bytes |
 
 Base triangles rose from **624 to 2508** in the quality pass: the old
 beveled cube with glued-on slats became a post-and-slat crate with
-tenons, sills, L-straps, and pipe handles.
+tenons, sills, L-straps, and pipe handles. The second pass took them to
+**3388**: single-shell chamfered straps, 24 nails, chamfered mounting
+plates.
 
-DECIMATE COLLAPSE triangle counts are **not** identical across series —
-5.2.1 is leaner on LOD2. The gate is a ratio band, not an exact count.
+DECIMATE COLLAPSE triangle counts are **not** guaranteed identical across
+series; on this mesh they happen to match (LOD2 744 on all three). 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. Slat-width jitter uses fixed seed 17.
 Export byte counts differ by 16 B on 5.2.1 (glTF serializer), not a
@@ -68,10 +71,42 @@ Recomputed from the generated mesh, not asserted about the script.
 | --- | --- | --- |
 | Handle-end BVH gap | ≤ 0.008 m | 0.00000 |
 | Slat-post BVH gap | ≤ 0.006 m | 0.00000 |
+| Nail seat | 24 nails; bite 0.3–1.0 mm into the strap, head ≥ 1.0 mm proud | 24; 0.60 mm; 1.80 mm |
+| Handle plates on one board | each plate inside a single end board with ≥ 4 mm clearance at both edges | 4 plates; 32.4 mm |
+
+### Second pass (straps, nails, handle placement, surface)
+
+The inspection sheet found the iron and the handles built the way
+`crate-stack` used to build them:
+
+- **Straps were two unbevelled boxes per corner.** That left a seam line
+  down the outer corner, razor edges, and an inner face sitting flush on
+  the post face. Each strap is now one L-section extrusion that bites
+  `IRON_BITE` into the post. It is chamfered at `IRON_BEVEL` with
+  `material=METAL_IDX`, since bevel otherwise hands chamfer faces slot 0.
+  Code copied from `crate-stack`, not imported.
+- **No fasteners.** Three nail stations per plate, 24 nails, placed from
+  each plate's own outer face and normal. `nail_audit` asserts the seat
+  band (exit 18, `--float-nails`).
+- **The handle mounting plates straddled the gap between two end
+  boards.** The handle sat at a fixed 52% of post height, which landed on
+  a gap. It now snaps to the centre of the end board nearest that height,
+  from the same `_span_layout` the boards come from. `plate_board_audit`
+  asserts each plate sits inside one board with clearance at both edges
+  (exit 20, `--straddle-handle`, which puts the handle on a gap and
+  measures −26.9 mm).
+- **Every plank was the same flat tone.** `PlankTone` / `GrainDir` face
+  attributes drive a grain-along-the-board wood shader. The iron gets
+  rust wear.
+- The temp glTF export is removed after it is measured.
+
+The right-angle-edge budget from `crate-stack` is not applied here: the
+handle bail's pipe ends are square discs buried in the mounting plates,
+so "every box is chamfered" does not hold for this piece.
 
 ### Falsifiers
 
-Each violates one named budget. All seven were run on 4.5.11, 5.1.2 and
+Each violates one named budget. All nine were run on 4.5.11, 5.1.2 and
 5.2.1 and returned the same code on each.
 
 | Flag | Budget violated | Exit |
@@ -82,6 +117,8 @@ Each violates one named budget. All seven were run on 4.5.11, 5.1.2 and
 | `--short-skids` | named skid supports at Z=0 | 16 |
 | `--float-handle` | handle-end gap | 17 |
 | `--omit-slats` | slat-post seat | 18 |
+| `--float-nails` | nail seat band (heads lifted 1.5 mm off the straps) | 18 |
+| `--straddle-handle` | handle plates on one end board | 20 |
 
 ## Run
 
@@ -93,6 +130,8 @@ blender --background --python shipping_crate.py -- --lift-z
 blender --background --python shipping_crate.py -- --short-skids
 blender --background --python shipping_crate.py -- --float-handle
 blender --background --python shipping_crate.py -- --omit-slats
+blender --background --python shipping_crate.py -- --float-nails
+blender --background --python shipping_crate.py -- --straddle-handle
 blender --background --python shipping_crate.py -- --output crate.png
 ```
 
@@ -124,5 +163,6 @@ hygiene and joint-fit family.
 | 15 | Mesh hygiene: loose, non-manifold, zero-area, doubles, n-gons, z-fight |
 | 16 | Not grounded: bounding box `zmin` off 0, or a named skid floats |
 | 17 | Joint fit: handle-end gap |
-| 18 | Seat: slat-post gap |
+| 18 | Seat: slat-post gap, or a nail head off its strap seat band (`--float-nails`) |
 | 19 | Body plan off the stated real-world size |
+| 20 | A handle mounting plate not seated on a single end board (`--straddle-handle`) |
diff --git a/showcase/shipping-crate/preview.webp b/showcase/shipping-crate/preview.webp
index 658045f5..aaa863ce 100644
Binary files a/showcase/shipping-crate/preview.webp and b/showcase/shipping-crate/preview.webp differ
diff --git a/showcase/shipping-crate/shipping_crate.py b/showcase/shipping-crate/shipping_crate.py
index d48c2e49..1457f8fe 100644
--- a/showcase/shipping-crate/shipping_crate.py
+++ b/showcase/shipping-crate/shipping_crate.py
@@ -1,7 +1,8 @@
 """Game-ready shipping crate — a showcase piece, not an example.
 
 Asserts budget conformance of a procedural crate (skids, corner posts,
-tenoned slats with seeded width jitter, L-straps, iron bail handles)
+tenoned slats with seeded width jitter, nailed single-shell L-straps,
+iron bail handles on one end board each)
 after composing shipped pipeline pieces: bmesh construction, UVs, two
 materials, high-to-low normal bake, LOD chain, convex collider, Unity
 glTF export.
@@ -15,9 +16,10 @@
 budget: ``--skip-decimate`` the LOD-ratio band, ``--stray-vert`` mesh
 hygiene, ``--lift-z`` grounded zmin, ``--short-skids`` named skid
 supports, ``--float-handle`` handle-to-end joint-fit, ``--omit-slats``
-slat-to-post seat.
+slat-to-post seat, ``--float-nails`` nail seat, ``--straddle-handle``
+handle plates on one board.
 
-Fixed seed 17 for slat-width jitter. DECIMATE COLLAPSE triangle counts
+Fixed seed 17 for slat-width jitter, 29 for plank tone. DECIMATE COLLAPSE triangle counts
 are not byte-identical across Blender versions — the LOD gate is a
 ratio band, not an exact count.
 
@@ -35,7 +37,7 @@
 
 import bmesh
 import bpy
-from mathutils import Vector
+from mathutils import Matrix, Vector
 from mathutils.bvhtree import BVHTree
 
 _REPO = os.path.abspath(
@@ -70,8 +72,8 @@
 BODY_X, BODY_Y, BODY_Z = 1.056, 0.716, 0.576
 BODY_TOL = 0.05
 
-BASE_TRIS_MIN = 1200
-BASE_TRIS_MAX = 2800
+BASE_TRIS_MIN = 2900
+BASE_TRIS_MAX = 3900
 LOD1_RATIO_MIN = 0.32
 LOD1_RATIO_MAX = 0.62
 LOD2_RATIO_MIN = 0.10
@@ -84,8 +86,8 @@
 COLLIDER_TRIS_MAX = 220
 BAKE_RES = 256
 CAGE_EXTRUSION = 0.08
-METAL_FACES_MIN = 48
-WOOD_FACES_MIN = 200
+METAL_FACES_MIN = 600
+WOOD_FACES_MIN = 900
 ZMIN_EPS = 1e-4
 DOUBLES_EPS = 1e-5
 AREA_EPS = 1e-10
@@ -99,6 +101,30 @@
 WOOD_IDX = 0
 METAL_IDX = 1
 
+# Straps bite into the post rather than sitting flush on it: a flush plate
+# puts its inner face on the post's outer face, one plane shared by two
+# shells. Chamfered at their own fine offset, a single L-section shell each.
+IRON_BITE = 0.0012
+IRON_BEVEL = 0.0008
+# Clout nails through each strap into the post, seated a named bite deep.
+NAIL_R = 0.0050
+NAIL_R_TOP = 0.0036
+NAIL_H = 0.0024
+NAIL_BITE = 0.0006
+NAIL_SEGS = 6
+NAIL_ZS = (0.12, 0.50, 0.88)
+NAIL_BITE_MIN = 0.0003
+NAIL_BITE_MAX = 0.0010
+NAIL_PROUD_MIN = 0.0010
+NAIL_EXTENT_MAX = IRON_WRAP * 0.5
+N_NAILS = 4 * 2 * len(NAIL_ZS)
+FLOAT_NAIL_LIFT = 0.0015
+# Handle mounting plates must sit on one end board, clear of both edges.
+PLATE_H = 0.044
+PLATE_BOARD_MARGIN = 0.004
+PLANK_TONE_JITTER = 0.28
+TONE_SEED = 29
+
 
 def eevee_engine_id():
     """EEVEE id: 'BLENDER_EEVEE' on 5.0+, 'BLENDER_EEVEE_NEXT' on 4.2-4.5.
@@ -296,6 +322,8 @@ def build_crate_mesh(
     short_skids=False,
     float_handle=False,
     omit_slats=False,
+    float_nails=False,
+    straddle_handle=False,
 ):
     ix, iy, iz = INNER
     hx = ix / 2.0 + POST / 2.0
@@ -427,6 +455,7 @@ def build_crate_mesh(
                         )
                     )
         end_c, end_w = _span_layout(N_END, iz - 0.04, rng)
+        end_z0 = SKID_H + 0.02 + iz / 2.0
         for sign in (-1.0, 1.0):
             x = sign * (ix / 2.0 + POST - SLAT_T / 2.0 - 0.001)
             for c, w in zip(end_c, end_w):
@@ -452,43 +481,46 @@ def build_crate_mesh(
                     clamp_overlap=True,
                 )
 
-        # L-straps: two plates meeting at a vertical edge, proud of the
-        # post. Not three overlapping cubes — those leave window holes.
-        wrap = IRON_WRAP
+        # L-straps: one extruded L-section shell per corner, biting into the
+        # post. Two boxes put a seam down the outer corner and, flush on
+        # the post, shared the post's face plane.
         strap_z0 = 0.006
         strap_h = top_z - strap_z0
-        zc = strap_z0 + strap_h / 2.0
+        px = hx + POST / 2.0 + IRON_T - IRON_BITE
+        py = hy + POST / 2.0 + IRON_T - IRON_BITE
+        iron = []
         for sxn in (-1.0, 1.0):
             for syn in (-1.0, 1.0):
-                ox = sxn * (hx + POST / 2.0 + IRON_T / 2.0)
-                oy = syn * (hy + POST / 2.0 + IRON_T / 2.0)
-                add_box(
-                    bm,
-                    (ox, syn * (hy + POST / 2.0 - wrap / 2.0 + IRON_T / 2.0), zc),
-                    (IRON_T, wrap, strap_h),
-                    METAL_IDX,
-                )
-                add_box(
-                    bm,
-                    (sxn * (hx + POST / 2.0 - wrap / 2.0 + IRON_T / 2.0), oy, zc),
-                    (wrap - IRON_T, IRON_T, strap_h),
-                    METAL_IDX,
-                )
-
-        hz = SKID_H + post_h * 0.52
+                iron.extend(add_strap(bm, sxn, syn, px, py, strap_z0, strap_h))
+                for fz in NAIL_ZS:
+                    z = strap_z0 + strap_h * fz
+                    add_nail(bm, Vector((sxn * px, syn * (py - IRON_WRAP * 0.5), z)),
+                             Vector((sxn, 0.0, 0.0)), float_nails)
+                    add_nail(bm, Vector((sxn * (px - IRON_WRAP * 0.5), syn * py, z)),
+                             Vector((0.0, syn, 0.0)), float_nails)
+
+        # The handle rides on the end board nearest mid-height, centred on
+        # it, so its mounting plates are screwed to wood, not to a gap.
+        # --straddle-handle puts it on the gap between two boards instead.
+        want = SKID_H + post_h * 0.52
+        k = min(range(N_END), key=lambda i: abs(end_z0 + end_c[i] - want))
+        hz = end_z0 + end_c[k]
+        if straddle_handle:
+            j = k + 1 if k + 1 < N_END else k - 1
+            hz = end_z0 + 0.5 * (end_c[k] + end_c[j])
         for sxn in (-1.0, 1.0):
             x_plate = sxn * (ix / 2.0 + POST - SLAT_T / 2.0)
             x_in = sxn * (ix / 2.0 + POST - SLAT_T - 0.008)
             x_out = sxn * (ix / 2.0 + POST + HANDLE_OUT)
             y0, y1 = -0.11, 0.11
-            add_box(
+            iron.extend(add_box(
                 bm, (x_plate, y0, hz),
-                (SLAT_T + IRON_T * 2.0, 0.034, 0.044), METAL_IDX,
-            )
-            add_box(
+                (SLAT_T + IRON_T * 2.0, 0.034, PLATE_H), METAL_IDX,
+            ))
+            iron.extend(add_box(
                 bm, (x_plate, y1, hz),
-                (SLAT_T + IRON_T * 2.0, 0.034, 0.044), METAL_IDX,
-            )
+                (SLAT_T + IRON_T * 2.0, 0.034, PLATE_H), METAL_IDX,
+            ))
             if float_handle:
                 add_box(
                     bm, (x_out, 0.0, hz), (0.020, 0.020, 0.020), METAL_IDX,
@@ -498,6 +530,19 @@ def build_crate_mesh(
                     bm, x_in, x_out, y0, y1, hz, HANDLE_R, 8, METAL_IDX,
                 )
 
+        # Chamfer the straps and mounting plates at their own offset; the
+        # flat diagonal inside each L cap is not a corner. material= keeps
+        # the chamfer faces iron (bevel otherwise hands them slot 0).
+        iron_edges = [
+            e for e in {e for v in iron if v.is_valid for e in v.link_edges}
+            if len(e.link_faces) == 2 and e.calc_face_angle(0.0) > 1e-3
+        ]
+        if iron_edges:
+            bmesh.ops.bevel(
+                bm, geom=iron_edges, offset=IRON_BEVEL, segments=1, profile=0.5,
+                affect="EDGES", clamp_overlap=True, material=METAL_IDX,
+            )
+
         pack_uvs(bm)
         bmesh.ops.recalc_face_normals(bm, faces=list(bm.faces))
         for face in bm.faces:
@@ -512,11 +557,175 @@ def build_crate_mesh(
         me.update()
     finally:
         bm.free()
+    paint_planks(me)
     obj = bpy.data.objects.new(name, me)
     bpy.context.collection.objects.link(obj)
     return obj
 
 
+def add_strap(bm, sxn, syn, px, py, z0, h):
+    """One L-section corner strap as a single closed shell (copied from crate-stack).
+
+    Each cap is two convex quads meeting on the inner-corner diagonal, so
+    there is no n-gon; the bottom cap is wound opposite the top.
+    """
+    outline = [
+        (px, py - IRON_WRAP),
+        (px, py),
+        (px - IRON_WRAP, py),
+        (px - IRON_WRAP, py - IRON_T),
+        (px - IRON_T, py - IRON_T),
+        (px - IRON_T, py - IRON_WRAP),
+    ]
+    rings = [[bm.verts.new((sxn * x, syn * y, z)) for x, y in outline] for z in (z0, z0 + h)]
+    lo, hi = rings
+    faces = []
+    for ring, flip in ((lo, True), (hi, False)):
+        for quad in ((0, 1, 4, 5), (1, 2, 3, 4)):
+            vs = [ring[k] for k in quad]
+            faces.append(bm.faces.new(vs[::-1] if flip else vs))
+    for i in range(len(outline)):
+        j = (i + 1) % len(outline)
+        faces.append(bm.faces.new((lo[i], lo[j], hi[j], hi[i])))
+    for f in faces:
+        f.material_index = METAL_IDX
+    return lo + hi
+
+
+def add_nail(bm, face_pt, nrm, lift=False):
+    """A frustum nail head seated NAIL_BITE into the plate at *face_pt*."""
+    geo = bmesh.ops.create_cone(
+        bm, cap_ends=True, cap_tris=True, segments=NAIL_SEGS,
+        radius1=NAIL_R, radius2=NAIL_R_TOP, depth=NAIL_H,
+    )
+    orient = nrm.to_track_quat("Z", "Y").to_matrix().to_4x4()
+    up = FLOAT_NAIL_LIFT if lift else 0.0
+    seat = Matrix.Translation(face_pt + nrm * up) @ orient @ Matrix.Translation(
+        (0.0, 0.0, NAIL_H / 2.0 - NAIL_BITE)
+    )
+    for v in geo["verts"]:
+        v.co = seat @ v.co
+    for f in {f for v in geo["verts"] for f in v.link_faces}:
+        f.material_index = METAL_IDX
+
+
+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."""
+    tone = [0.5] * len(me.polygons)
+    grain = [(1.0, 0.0, 0.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((1.0, 0.0, 0.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 board (``GrainDir``), tone per board (``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 = 30.0
+    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 crate_materials():
+    """(wood, iron): shared by the check, the render and inspection."""
+    wood = wood_material("CrateWood")
+    metal = principled(
+        "CrateMetal", (0.17, 0.165, 0.155, 1.0), 0.80, 0.46,
+        noise_scale=18.0, wear=(0.20, 0.085, 0.032, 1.0),
+    )
+    return wood, metal
+
+
 def principled(name, color, metallic, roughness, noise_scale=0.0, wear=None):
     mat = bpy.data.materials.new(name)
     mat.use_nodes = True
@@ -799,6 +1008,72 @@ def slat_join(me):
     return _bvh_gap(me, posts, slats)
 
 
+def nail_audit(me):
+    """Seat of every nail head in its strap (copied from crate-stack).
+
+    Nails are the small iron shells; every other iron shell is a host.
+    Signed distance to the host surface per nail vertex: the deepest is
+    the bite (banded), the highest is how proud the head stands.
+    """
+    nails, hosts = [], []
+    for g in shells(me):
+        if mat_of(me, g) != METAL_IDX:
+            continue
+        a = shell_aabb(me, g)
+        ext = max(a[3] - a[0], a[4] - a[1], a[5] - a[2])
+        (nails if ext < NAIL_EXTENT_MAX else hosts).append(g)
+    if not nails or not hosts:
+        return {"n": len(nails), "bite_min": 0.0, "bite_max": 0.0, "proud_min": 0.0}
+    bm = bmesh.new()
+    try:
+        bm.from_mesh(me)
+        keep = {i for g in hosts for i in g}
+        drop = [f for f in bm.faces if not all(v.index in keep for v in f.verts)]
+        bmesh.ops.delete(bm, geom=drop, context="FACES")
+        tree = BVHTree.FromBMesh(bm)
+    finally:
+        bm.free()
+    bites, prouds = [], []
+    for g in nails:
+        signed = []
+        for i in g:
+            co = me.vertices[i].co
+            loc, nrm, _idx, _d = tree.find_nearest(co)
+            signed.append(99.0 if loc is None else (co - loc).dot(nrm))
+        bites.append(-min(signed))
+        prouds.append(max(signed))
+    return {"n": len(nails), "bite_min": min(bites), "bite_max": max(bites),
+            "proud_min": min(prouds)}
+
+
+def plate_board_audit(me):
+    """Worst clearance of a handle mounting plate inside a single end board.
+
+    End boards are the thin wood shells standing across an end of the
+    crate; mounting plates are the iron shells PLATE_H tall. For each plate
+    the clearance is how far its z-range sits inside the best-fitting
+    board's z-range, at both edges. Negative means the plate hangs over a
+    board edge, onto the gap.
+    """
+    boards, plates = [], []
+    for g in shells(me):
+        a = shell_aabb(me, g)
+        dx, dy, dz = a[3] - a[0], a[4] - a[1], a[5] - a[2]
+        m = mat_of(me, g)
+        if m == WOOD_IDX and dx < SLAT_T * 2.5 and dy > INNER[1] * 0.8 and dz < INNER[2] * 0.5:
+            boards.append(a)
+        elif m == METAL_IDX and abs(dz - PLATE_H) < 0.004 and dy < 0.05:
+            plates.append(a)
+    worst = 99.0
+    for pa in plates:
+        side = [b for b in boards if abs(0.5 * (b[0] + b[3]) - 0.5 * (pa[0] + pa[3])) < 0.05]
+        best = max(
+            (min(pa[2] - b[2], b[5] - pa[5]) for b in side), default=-99.0
+        )
+        worst = min(worst, best)
+    return {"plates": len(plates), "boards": len(boards), "clear": worst}
+
+
 def add_stray_vert(me):
     bm = bmesh.new()
     try:
@@ -905,23 +1180,20 @@ def check(
     short_skids=False,
     float_handle=False,
     omit_slats=False,
+    float_nails=False,
+    straddle_handle=False,
 ):
     bpy.ops.wm.read_factory_settings(use_empty=True)
     flags = dict(
         short_skids=short_skids,
         float_handle=float_handle,
         omit_slats=omit_slats,
+        float_nails=float_nails,
+        straddle_handle=straddle_handle,
     )
     low = build_crate_mesh("CrateLow", **flags)
     high = build_crate_mesh("CrateHigh", **flags)
-    wood = principled(
-        "CrateWood", (0.48, 0.22, 0.07, 1.0), 0.0, 0.50,
-        noise_scale=7.0, wear=(0.28, 0.14, 0.05, 1.0),
-    )
-    metal = principled(
-        "CrateMetal", (0.18, 0.17, 0.16, 1.0), 0.86, 0.36,
-        noise_scale=5.0, wear=(0.10, 0.09, 0.08, 1.0),
-    )
+    wood, metal = crate_materials()
     assign_slots(low, wood, metal)
     assign_slots(high, wood, metal)
     if stray_vert:
@@ -975,6 +1247,10 @@ 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
+    # Blender points TMPDIR at its own temp preference, which on a portable
+    # build is the working directory, so the export must not outlive this.
+    if os.path.isfile(export_path):
+        os.remove(export_path)
 
     hyg = hygiene_audit(low.data)
     zf = zfight_pairs(low.data)
@@ -982,6 +1258,8 @@ def check(
     body = body_audit(low.data)
     hj = handle_join(low.data)
     sj = slat_join(low.data)
+    nails = nail_audit(low.data)
+    pb = plate_board_audit(low.data)
 
     print(f"blender={tuple(bpy.app.version)} skip_decimate={skip_decimate}")
     print(
@@ -1010,6 +1288,11 @@ def check(
         f"body=({body['dx']:.4f},{body['dy']:.4f},{body['dz']:.4f}) "
         f"handle_join={hj:.5f} slat_join={sj:.5f}"
     )
+    print(
+        f"measured nails n={nails['n']} bite=[{nails['bite_min']:.5f}, "
+        f"{nails['bite_max']:.5f}] proud_min={nails['proud_min']:.5f} "
+        f"plates={pb['plates']} boards={pb['boards']} plate_clear={pb['clear']:.5f}"
+    )
 
     if not (BASE_TRIS_MIN <= base_tris <= BASE_TRIS_MAX):
         return fail(
@@ -1108,10 +1391,31 @@ def check(
             "(--omit-slats is the designed fail)",
             18,
         ), None, None, None, None, None
+    if (
+        nails["n"] != N_NAILS
+        or nails["bite_min"] < NAIL_BITE_MIN
+        or nails["bite_max"] > NAIL_BITE_MAX
+        or nails["proud_min"] < NAIL_PROUD_MIN
+    ):
+        return fail(
+            f"nail seat: {nails['n']} of {N_NAILS} nails, bite "
+            f"[{nails['bite_min']:.5f}, {nails['bite_max']:.5f}] outside "
+            f"[{NAIL_BITE_MIN}, {NAIL_BITE_MAX}] or proud "
+            f"{nails['proud_min']:.5f} < {NAIL_PROUD_MIN} "
+            "(--float-nails is the designed fail)",
+            18,
+        ), None, None, None, None, None
     if abs(body["dx"] - BODY_X) > BODY_TOL:
         return fail(f"body dx {body['dx']:.4f} off {BODY_X}", 19), None, None, None, None, None
     if abs(body["dy"] - BODY_Y) > BODY_TOL:
         return fail(f"body dy {body['dy']:.4f} off {BODY_Y}", 19), None, None, None, None, None
+    if pb["plates"] != 4 or pb["clear"] < PLATE_BOARD_MARGIN:
+        return fail(
+            f"handle plates {pb['plates']} clear of board edges by "
+            f"{pb['clear']:.5f} < {PLATE_BOARD_MARGIN} "
+            "(--straddle-handle is the designed fail)",
+            20,
+        ), None, None, None, None, None
     return 0, low, high, wood, tex, collider
 
 
@@ -1231,6 +1535,8 @@ def main():
     p.add_argument("--short-skids", action="store_true")
     p.add_argument("--float-handle", action="store_true")
     p.add_argument("--omit-slats", action="store_true")
+    p.add_argument("--float-nails", action="store_true")
+    p.add_argument("--straddle-handle", action="store_true")
     args = p.parse_args(argv)
 
     code, low, _high, wood, tex, _col = check(
@@ -1240,6 +1546,8 @@ def main():
         short_skids=args.short_skids,
         float_handle=args.float_handle,
         omit_slats=args.omit_slats,
+        float_nails=args.float_nails,
+        straddle_handle=args.straddle_handle,
     )
     if code:
         return code