diff --git a/docs/gallery/assets/crate-stack-hero.webp b/docs/gallery/assets/crate-stack-hero.webp
index c2cbd00b..81df3856 100644
Binary files a/docs/gallery/assets/crate-stack-hero.webp and b/docs/gallery/assets/crate-stack-hero.webp differ
diff --git a/docs/gallery/assets/depsgraph-export-hero.webp b/docs/gallery/assets/depsgraph-export-hero.webp
index 8fc128df..80b0308b 100644
Binary files a/docs/gallery/assets/depsgraph-export-hero.webp and b/docs/gallery/assets/depsgraph-export-hero.webp differ
diff --git a/docs/gallery/contact-sheets/crate-stack-contact-sheet.webp b/docs/gallery/contact-sheets/crate-stack-contact-sheet.webp
index 6da93537..3275e395 100644
Binary files a/docs/gallery/contact-sheets/crate-stack-contact-sheet.webp and b/docs/gallery/contact-sheets/crate-stack-contact-sheet.webp differ
diff --git a/docs/gallery/contact-sheets/depsgraph-export-contact-sheet.webp b/docs/gallery/contact-sheets/depsgraph-export-contact-sheet.webp
index 7fe083eb..448cb796 100644
Binary files a/docs/gallery/contact-sheets/depsgraph-export-contact-sheet.webp and b/docs/gallery/contact-sheets/depsgraph-export-contact-sheet.webp differ
diff --git a/docs/gallery/crate-stack/index.html b/docs/gallery/crate-stack/index.html
index 7692035a..51d900f5 100644
--- a/docs/gallery/crate-stack/index.html
+++ b/docs/gallery/crate-stack/index.html
@@ -16,13 +16,13 @@
   <meta property="og:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/crate-stack-hero.webp" />
   <meta property="og:image:width" content="1280" />
   <meta property="og:image:height" content="720" />
-  <meta property="og:image:alt" content="Three wooden shipping crates stacked, each turned slightly differently." />
+  <meta property="og:image:alt" content="Three grained wooden shipping crates stacked, each turned slightly differently, with nailed iron corner straps." />
   <meta property="og:site_name" content="Blender Developer Tools" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="crate-stack — Showcase — Blender Developer Tools" />
   <meta name="twitter:description" content="A stack of three procedural shipping crates built by one generator called three times with a per-instance seed, carried 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/crate-stack-hero.webp" />
-  <meta name="twitter:image:alt" content="Three wooden shipping crates stacked, each turned slightly differently." />
+  <meta name="twitter:image:alt" content="Three grained wooden shipping crates stacked, each turned slightly differently, with nailed iron corner straps." />
   <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>crate-stack</h1>
     <p>A stack of three procedural shipping crates built by one generator called three times with a per-instance seed, carried 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: Three wooden shipping crates stacked, each turned slightly differently.">
-      <img src="../assets/crate-stack-hero.webp" alt="Three wooden shipping crates stacked, each turned slightly differently." width="1280" height="720" />
+    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: Three grained wooden shipping crates stacked, each turned slightly differently, with nailed iron corner straps.">
+      <img src="../assets/crate-stack-hero.webp" alt="Three grained wooden shipping crates stacked, each turned slightly differently, with nailed iron corner straps." 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: 4380 tris, two materials with 216 iron and 2436 timber faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.658×0.524×0.704 m, zmin 0, hygiene 0 including zero coplanar disjoint pairs, three ground runners at z=0, both crate-to-crate seats overlapping, each crate&#x27;s own footprint 0.585×0.425 m measured in its own frame, yaw spread 0.026 rad and plank spread 2.05 mm across instances, LOD ratios in band, convex collider 202 tris, non-empty glTF. --float-stack exits 18 on the seat; --same-seed exits 20 on per-instance variation.</div>
@@ -281,32 +281,38 @@ <h1>crate-stack</h1>
 <p>A stack of three shipping crates. <strong>A showcase piece, not an example</strong> — it witnesses no API contract. It asserts that generated geometry meets declared asset budgets, recomputed from the finished mesh.</p>
 <h2>What it composes</h2>
 <p>One <code>build_crate</code> generator, invoked three times with a per-instance seed, then the shipped pipeline:</p>
-<div class="table-wrap"><table><thead><tr><th scope="col">Shipped content</th><th scope="col">Used for</th></tr></thead><tbody><tr><td><code>skills/mesh-editing-and-bmesh</code></td><td>box, bevel and UV construction in one <code>bmesh</code></td></tr><tr><td><code>skills/procedural-materials-and-shaders</code></td><td>two Principled materials with noise-driven wear</td></tr><tr><td><code>skills/bake-high-to-low</code></td><td>Cycles tangent-space normal bake, high onto low</td></tr><tr><td><code>skills/engine-export-presets</code></td><td>Unity glTF (<code>export_yup=True</code>)</td></tr><tr><td><code>skills/depsgraph-and-evaluated-data</code></td><td>evaluated triangle counts for the LOD ratios</td></tr><tr><td><code>snippets/decimate_to_budget.py</code></td><td>LOD1 / LOD2 COLLAPSE chain</td></tr><tr><td><code>snippets/convex_hull_collider.py</code></td><td>convex collider</td></tr><tr><td><code>snippets/lod_chain.py</code></td><td>LOD naming and ratio pattern</td></tr><tr><td><code>examples/mesh-hygiene-audit</code></td><td>hygiene combinatorics (copied, not imported)</td></tr></tbody></table></div>
+<div class="table-wrap"><table><thead><tr><th scope="col">Shipped content</th><th scope="col">Used for</th></tr></thead><tbody><tr><td><code>skills/mesh-editing-and-bmesh</code></td><td>box, bevel and UV construction in one <code>bmesh</code></td></tr><tr><td><code>skills/procedural-materials-and-shaders</code></td><td>attribute-driven timber (per-plank tone, grain along each board) and rusted iron</td></tr><tr><td><code>skills/bake-high-to-low</code></td><td>Cycles tangent-space normal bake, high onto low</td></tr><tr><td><code>skills/engine-export-presets</code></td><td>Unity glTF (<code>export_yup=True</code>)</td></tr><tr><td><code>skills/depsgraph-and-evaluated-data</code></td><td>evaluated triangle counts for the LOD ratios</td></tr><tr><td><code>snippets/decimate_to_budget.py</code></td><td>LOD1 / LOD2 COLLAPSE chain</td></tr><tr><td><code>snippets/convex_hull_collider.py</code></td><td>convex collider</td></tr><tr><td><code>snippets/lod_chain.py</code></td><td>LOD naming and ratio pattern</td></tr><tr><td><code>examples/mesh-hygiene-audit</code></td><td>hygiene combinatorics (copied, not imported)</td></tr></tbody></table></div>
 <h2>Reuse with variation</h2>
 <p>The point of the piece. Each crate comes out of the same generator; what differs is the seed. That seed drives the yaw, the plank widths, and the board heights, so the three read as three of the same design rather than one model pasted three times.</p>
 <p>True instancing — three objects sharing one mesh datablock — and per-instance geometry variation are mutually exclusive. This piece takes the variation, and the shipped asset is the flattened single mesh an engine would receive. The generator is reused; the geometry is not.</p>
 <p>Two independent random streams keep that honest. The <strong>design</strong> stream (yaw, plank widths) is what <code>--same-seed</code> collapses. The <strong>placement</strong> stream (lateral offsets) stays per-instance either way, so a falsified stack has the same footprint as a good one and fails on the variation budget rather than on the bounding box.</p>
 <h2>Budgets</h2>
 <p>Declared in the script as named constants, recomputed from the generated mesh. Measured values below are from Blender 5.2.1; see the table at the end for the 4.5.11 / 5.1.2 figures.</p>
-<div class="table-wrap"><table><thead><tr><th scope="col">Budget</th><th scope="col">Band</th><th scope="col">Measured</th></tr></thead><tbody><tr><td>Base triangles</td><td>3200–7200</td><td>4380</td></tr><tr><td>LOD1 ratio</td><td>0.32–0.62</td><td>0.5000</td></tr><tr><td>LOD2 ratio</td><td>0.10–0.35</td><td>0.2005 (5.2) / 0.2199 (4.5, 5.1)</td></tr><tr><td>Material slots</td><td>exactly 2, distinct</td><td>2</td></tr><tr><td>Iron faces</td><td>≥ 120</td><td>216</td></tr><tr><td>Timber faces</td><td>≥ 600</td><td>2436</td></tr><tr><td>UV bounds</td><td>inside 0..1</td><td>(0.0008, 0.0008)–(0.9992, 0.9992)</td></tr><tr><td>UV AABB overlap</td><td>≤ 1e-5</td><td>0.000000</td></tr><tr><td>Outer AABB</td><td>0.658 × 0.524 × 0.704 m ± 0.020</td><td>0.6582 × 0.5235 × 0.7040</td></tr><tr><td>Crate body footprint</td><td>0.585 × 0.425 m ± 0.015, in the crate&#x27;s own frame</td><td>0.5846 × 0.4246 (all three)</td></tr><tr><td>Collider triangles</td><td>≤ 260</td><td>202</td></tr><tr><td>Normal bake</td><td><code>{&#x27;FINISHED&#x27;}</code> with image data</td><td><code>{&#x27;FINISHED&#x27;}</code>, <code>has_data=True</code></td></tr><tr><td>glTF export</td><td>file written, non-empty</td><td>~340 kB</td></tr><tr><td>Hygiene</td><td>all zero</td><td>loose 0/0, non-manifold 0, zero-area 0, doubles 0, n-gons 0, coplanar disjoint pairs 0</td></tr><tr><td>Grounded AABB</td><td>\</td><td>zmin\</td><td>≤ 1e-4</td><td>0.00000</td></tr><tr><td>Ground runners</td><td>3 named supports, each zmin ≤ 1e-3</td><td>3 at 0.00000</td></tr><tr><td>Crate-to-crate seat</td><td>both seats, surface gap ≤ 0.0015 m</td><td>0.00000 (overlapping)</td></tr><tr><td>Yaw band</td><td>each \</td><td>yaw\</td><td>in 0.040–0.192 rad</td><td>0.0681, 0.0943, 0.1093</td></tr><tr><td>Per-instance variation</td><td>yaw spread ≥ 0.020 rad, plank spread ≥ 0.0008 m</td><td>0.0262 rad, 0.00205 m</td></tr></tbody></table></div>
-<p>Real-world size: each crate is 0.58 × 0.42 m at the timber and 0.585 × 0.425 m over the corner iron, 0.244 m tall including runners and lid. Three stacked come to 0.70 m — knee height, wider than tall.</p>
+<div class="table-wrap"><table><thead><tr><th scope="col">Budget</th><th scope="col">Band</th><th scope="col">Measured</th></tr></thead><tbody><tr><td>Base triangles</td><td>5200–7000</td><td>6060</td></tr><tr><td>LOD1 ratio</td><td>0.32–0.62</td><td>0.5000</td></tr><tr><td>LOD2 ratio</td><td>0.10–0.35</td><td>0.2198</td></tr><tr><td>Material slots</td><td>exactly 2, distinct</td><td>2</td></tr><tr><td>Iron faces</td><td>≥ 900</td><td>1344</td></tr><tr><td>Timber faces</td><td>≥ 1800</td><td>2418</td></tr><tr><td>UV bounds</td><td>inside 0..1</td><td>(0.0006, 0.0007)–(0.9994, 0.9993)</td></tr><tr><td>UV AABB overlap</td><td>≤ 1e-5</td><td>0.000000</td></tr><tr><td>Outer AABB</td><td>0.658 × 0.524 × 0.704 m ± 0.020</td><td>0.6583 × 0.5235 × 0.7040</td></tr><tr><td>Crate body footprint</td><td>0.588 × 0.428 m ± 0.015, in the crate&#x27;s own frame</td><td>0.5882 × 0.4282 (all three)</td></tr><tr><td>Collider triangles</td><td>≤ 260</td><td>230</td></tr><tr><td>Normal bake</td><td><code>{&#x27;FINISHED&#x27;}</code> with image data</td><td><code>{&#x27;FINISHED&#x27;}</code>, <code>has_data=True</code></td></tr><tr><td>glTF export</td><td>file written, non-empty</td><td>~490 kB</td></tr><tr><td>Hygiene</td><td>all zero</td><td>loose 0/0, non-manifold 0, zero-area 0, doubles 0, n-gons 0, coplanar disjoint pairs 0</td></tr><tr><td>Grounded AABB</td><td>\</td><td>zmin\</td><td>≤ 1e-4</td><td>0.00000</td></tr><tr><td>Ground runners</td><td>3 named supports, each zmin ≤ 1e-3</td><td>3 at 0.00000</td></tr><tr><td>Crate-to-crate seat</td><td>both seats, surface gap ≤ 0.0015 m</td><td>0.00000 (overlapping)</td></tr><tr><td>Yaw band</td><td>each \</td><td>yaw\</td><td>in 0.040–0.192 rad</td><td>0.0681, 0.0943, 0.1093</td></tr><tr><td>Per-instance variation</td><td>yaw spread ≥ 0.020 rad, plank spread ≥ 0.0008 m</td><td>0.0262 rad, 0.00205 m</td></tr><tr><td>Nail seat</td><td>48 nails; bite 0.3–1.0 mm into the strap, head ≥ 1.0 mm proud</td><td>48; bite 0.60 mm, proud 1.80 mm</td></tr><tr><td>Edge treatment</td><td>manifold edges within 5° of a right angle: 0</td><td>timber 0, iron 0</td></tr></tbody></table></div>
+<p>Real-world size: each crate is 0.58 × 0.42 m at the timber and 0.588 × 0.428 m over the corner iron and its nail heads, 0.244 m tall including runners and lid. Three stacked come to 0.70 m — knee height, wider than tall.</p>
 <h3>Why the footprint is measured in the crate&#x27;s own frame</h3>
-<p>The stack AABB is the union of three yawed boxes, so a crate could drift to any size underneath it and the outer budget would not notice. Each crate&#x27;s footprint is therefore measured after un-rotating by the yaw that crate was <em>measured</em> to have, not the yaw it was built with. All three land on 0.5846 × 0.4246 m exactly, which is what makes the un-rotation trustworthy.</p>
+<p>The stack AABB is the union of three yawed boxes, so a crate could drift to any size underneath it and the outer budget would not notice. Each crate&#x27;s footprint is therefore measured after un-rotating by the yaw that crate was <em>measured</em> to have, not the yaw it was built with. All three land on 0.5882 × 0.4282 m exactly, which is what makes the un-rotation trustworthy.</p>
 <h3>Why parts are classified by principal axes</h3>
 <p>Every part is an axis-aligned box in its crate&#x27;s frame and then rotated about Z. A world-AABB shape filter measures the rotated bounding box, not the part: a 0.554 m board yawed 0.09 rad reports 0.061 m of depth instead of its 0.013 m thickness, and every filter keyed to thickness silently matches nothing. <code>xy_principal</code> recovers each box&#x27;s own axes, and hands back the yaw as a by-product — which is where the variation budget&#x27;s yaw numbers come from.</p>
 <h3>Why stack levels come from the runners</h3>
 <p>Binning parts against the declared stack pitch put a lid — which sits 8 mm below the next crate&#x27;s base — on the wrong level the moment a falsifier shifted a crate, and the seat budget then compared a crate against itself. The bands are clustered from the runner heights the mesh actually has, so they follow the geometry including when a falsifier moves it.</p>
+<h3>Why the corner iron is one shell</h3>
+<p>Each strap used to be two overlapping boxes, one per leg of the L. Both boxes had a vertical edge on the strap&#x27;s outer corner, and once the iron was chamfered each box laid a chamfer strip on that same line: a coplanar cross-shell pair at all twelve corners, which the z-fight budget caught. The strap is now a single L-section extrusion — each cap two convex quads meeting on the inner-corner diagonal, so no n-gon — with one outer corner. The iron bevel passes <code>material=METAL_IDX</code>; left to its default, bevel gave the chamfer faces slot 0 and the plates rendered and classified as timber.</p>
+<h3>Why nails are told from plates by the strap&#x27;s size</h3>
+<p>Nail and plate shells are both iron; the nail audit separates them by world-AABB extent. The threshold is <code>IRON_WRAP * 0.5</code>, derived from the strap. A fixed 10 mm threshold dropped 8 of 48 nails as soon as the heads grew to 10 mm, because a yawed head&#x27;s world AABB is wider than the head.</p>
+<h3>Timber surface</h3>
+<p><code>paint_planks</code> writes two face attributes: <code>PlankTone</code>, a seeded tone per shell, and <code>GrainDir</code>, the shell&#x27;s own long axis recovered from its vertices. The wood shader samples noise in object space with the component along <code>GrainDir</code> compressed, so the grain streaks run along each board whatever the crate&#x27;s yaw, and scales the colour by the plank&#x27;s tone. Neither attribute is a budget: a tone cannot be seen by an assertion, which is why the inspection sheet looked at it.</p>
 <h2>Determinism</h2>
-<p>Fixed seed 41; no unseeded randomness. Identical geometry across runs on one binary and across 4.5.11, 5.1.2 and 5.2.1 — every measured value above is byte-identical on the three <strong>except</strong> LOD2, where <code>DECIMATE COLLAPSE</code> produces 878 triangles on 5.2 and 934 on 4.5 and 5.1. That is why the LOD gate is a ratio band (0.10–0.35, measured 0.2005 and 0.2199) and not an exact count.</p>
+<p>Fixed seed 41; no unseeded randomness. Identical geometry across runs on one binary and across 4.5.11, 5.1.2 and 5.2.1 — every measured value above is byte-identical on the three. LOD2 used to differ — <code>DECIMATE COLLAPSE</code> produced 878 triangles on 5.2 and 934 on 4.5 and 5.1 on the earlier mesh — and on the current mesh lands on 1332 on all three. The LOD gate stays a ratio band (0.10–0.35) rather than an exact count, because that agreement is a property of this mesh, not of the modifier.</p>
 <h2>Falsifiers</h2>
-<p>Each breaks one pipeline stage so a <strong>named</strong> budget fails. All six were run on 4.5.11, 5.1.2 and 5.2.1 and produced the same exit code on all three.</p>
-<div class="table-wrap"><table><thead><tr><th scope="col">Flag</th><th scope="col">Breaks</th><th scope="col">Exit</th></tr></thead><tbody><tr><td><code>--skip-decimate</code></td><td>drops the DECIMATE modifiers, LOD1 ratio goes to 1.0000</td><td>9</td></tr><tr><td><code>--stray-vert</code></td><td>adds one loose vertex <em>inside</em> the silhouette, so hygiene catches it rather than the bounding box</td><td>15</td></tr><tr><td><code>--lift-z</code></td><td>lifts the whole mesh 50 mm off the floor</td><td>16</td></tr><tr><td><code>--short-skids</code></td><td>floats <strong>one</strong> of the three ground runners 12 mm; the other two still ground the AABB, so only the named-support budget sees it</td><td>16</td></tr><tr><td><code>--float-stack</code></td><td>lifts the top crate 9 mm clear of the lid below, opening a 34 mm seat gap</td><td>18</td></tr><tr><td><code>--same-seed</code></td><td>gives all three crates the same design seed; yaw spread and plank spread both go to 0</td><td>20</td></tr></tbody></table></div>
+<p>Each breaks one pipeline stage so a <strong>named</strong> budget fails. All eight were run on 4.5.11, 5.1.2 and 5.2.1 and produced the same exit code on all three.</p>
+<div class="table-wrap"><table><thead><tr><th scope="col">Flag</th><th scope="col">Breaks</th><th scope="col">Exit</th></tr></thead><tbody><tr><td><code>--skip-decimate</code></td><td>drops the DECIMATE modifiers, LOD1 ratio goes to 1.0000</td><td>9</td></tr><tr><td><code>--stray-vert</code></td><td>adds one loose vertex <em>inside</em> the silhouette, so hygiene catches it rather than the bounding box</td><td>15</td></tr><tr><td><code>--lift-z</code></td><td>lifts the whole mesh 50 mm off the floor</td><td>16</td></tr><tr><td><code>--short-skids</code></td><td>floats <strong>one</strong> of the three ground runners 12 mm; the other two still ground the AABB, so only the named-support budget sees it</td><td>16</td></tr><tr><td><code>--float-stack</code></td><td>lifts the top crate 9 mm clear of the lid below, opening a 34 mm seat gap</td><td>18</td></tr><tr><td><code>--same-seed</code></td><td>gives all three crates the same design seed; yaw spread and plank spread both go to 0</td><td>20</td></tr><tr><td><code>--float-nails</code></td><td>lifts every nail head 1.5 mm along its plate normal; bite goes to −0.90 mm, nail seat budget</td><td>18</td></tr><tr><td><code>--sharp-iron</code></td><td>skips the iron chamfer pass; 216 right-angle iron edges, edge-treatment budget</td><td>21</td></tr></tbody></table></div>
 <h2>Exit codes</h2>
 <p>File-local and sequential. <code>9</code> is a valid check code; there is no rule against it. <code>1</code> is the FATAL wrapper — a crash, never a named check.</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, or has no UV layer</td></tr><tr><td>4</td><td>Base triangle count outside band</td></tr><tr><td>5</td><td>Material slots, or a material&#x27;s face floor</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>Outer AABB off declared size</td></tr><tr><td>9</td><td>LOD1 or LOD2 ratio outside band (<code>--skip-decimate</code>)</td></tr><tr><td>10</td><td>Framing gate (<code>examples/gallery_framing.py</code>, render path only)</td></tr><tr><td>11</td><td>Collider triangles above ceiling</td></tr><tr><td>12</td><td>Normal bake failed or produced no image data</td></tr><tr><td>13</td><td>glTF export 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 (<code>--stray-vert</code>)</td></tr><tr><td>16</td><td>Grounded zmin, or a named ground runner floating (<code>--lift-z</code>, <code>--short-skids</code>)</td></tr><tr><td>18</td><td>Crate-to-crate seat gap (<code>--float-stack</code>)</td></tr><tr><td>19</td><td>Crate body footprint off declared size</td></tr><tr><td>20</td><td>Per-instance variation collapsed (<code>--same-seed</code>)</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, or has no UV layer</td></tr><tr><td>4</td><td>Base triangle count outside band</td></tr><tr><td>5</td><td>Material slots, or a material&#x27;s face floor</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>Outer AABB off declared size</td></tr><tr><td>9</td><td>LOD1 or LOD2 ratio outside band (<code>--skip-decimate</code>)</td></tr><tr><td>10</td><td>Framing gate (<code>examples/gallery_framing.py</code>, render path only)</td></tr><tr><td>11</td><td>Collider triangles above ceiling</td></tr><tr><td>12</td><td>Normal bake failed or produced no image data</td></tr><tr><td>13</td><td>glTF export 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 (<code>--stray-vert</code>)</td></tr><tr><td>16</td><td>Grounded zmin, or a named ground runner floating (<code>--lift-z</code>, <code>--short-skids</code>)</td></tr><tr><td>18</td><td>Crate-to-crate seat gap (<code>--float-stack</code>), or a nail head off its strap seat band (<code>--float-nails</code>)</td></tr><tr><td>19</td><td>Crate body footprint off declared size</td></tr><tr><td>20</td><td>Per-instance variation collapsed (<code>--same-seed</code>)</td></tr><tr><td>21</td><td>A manifold edge within 5° of a right angle: a chamfer pass skipped (<code>--sharp-iron</code>)</td></tr></tbody></table></div>
 <p><code>17</code> is unused here: this piece has no diagonal member. <code>15</code>–<code>19</code> are reserved across showcase pieces for the hygiene family, so the numbering skips rather than reuses.</p>
 <h2>Run it</h2>
-<pre><code># Budget check, no render. ~1.0 s on 4.5/5.1, ~1.2 s on 5.2.
+<pre><code># Budget check, no render. ~1.4-1.7 s on 4.5 / 5.1 / 5.2.
 blender --background --python crate_stack.py --
 
 # Falsifier: the three crates become copies. Must exit 20.
@@ -319,7 +325,7 @@ <h2>Run it</h2>
 blender --background --python crate_stack.py -- --output stack.webp</code></pre>
 <p>Smoke runs the check-only path. It does not pass <code>--output</code> or any falsifier.</p>
 <h2>Cross-version measurements</h2>
-<div class="table-wrap"><table><thead><tr><th scope="col">Value</th><th scope="col">4.5.11</th><th scope="col">5.1.2</th><th scope="col">5.2.1</th></tr></thead><tbody><tr><td>Base triangles</td><td>4380</td><td>4380</td><td>4380</td></tr><tr><td>LOD1 tris / ratio</td><td>2190 / 0.5000</td><td>2190 / 0.5000</td><td>2190 / 0.5000</td></tr><tr><td>LOD2 tris / ratio</td><td>934 / 0.2199</td><td>934 / 0.2199</td><td>878 / 0.2005</td></tr><tr><td>Outer AABB</td><td>0.6582 × 0.5235 × 0.7040</td><td>same</td><td>same</td></tr><tr><td>Collider tris</td><td>202</td><td>202</td><td>202</td></tr><tr><td>Yaws (rad)</td><td>0.0943, −0.1093, 0.0681</td><td>same</td><td>same</td></tr><tr><td>Seat gap</td><td>0.00000</td><td>0.00000</td><td>0.00000</td></tr><tr><td>Check wall-clock</td><td>~0.99 s</td><td>~1.01 s</td><td>~1.20 s</td></tr></tbody></table></div>
+<div class="table-wrap"><table><thead><tr><th scope="col">Value</th><th scope="col">4.5.11</th><th scope="col">5.1.2</th><th scope="col">5.2.1</th></tr></thead><tbody><tr><td>Base triangles</td><td>6060</td><td>6060</td><td>6060</td></tr><tr><td>LOD1 tris / ratio</td><td>3030 / 0.5000</td><td>3030 / 0.5000</td><td>3030 / 0.5000</td></tr><tr><td>LOD2 tris / ratio</td><td>1332 / 0.2198</td><td>1332 / 0.2198</td><td>1332 / 0.2198</td></tr><tr><td>Outer AABB</td><td>0.6583 × 0.5235 × 0.7040</td><td>same</td><td>same</td></tr><tr><td>Collider tris</td><td>230</td><td>230</td><td>230</td></tr><tr><td>Yaws (rad)</td><td>0.0943, −0.1093, 0.0681</td><td>same</td><td>same</td></tr><tr><td>Seat gap</td><td>0.00000</td><td>0.00000</td><td>0.00000</td></tr><tr><td>Nails / bite / proud</td><td>48 / 0.60 mm / 1.80 mm</td><td>same</td><td>same</td></tr><tr><td>Right-angle edges</td><td>0</td><td>0</td><td>0</td></tr><tr><td>Check wall-clock</td><td>~1.59 s</td><td>~1.41 s</td><td>~1.65 s</td></tr></tbody></table></div>
     </section>
     <section class="detail-section src">
       <h2>Source</h2>
@@ -349,7 +355,8 @@ <h2>Source</h2>
 budget: ``--skip-decimate`` the LOD-ratio band, ``--stray-vert`` mesh
 hygiene, ``--lift-z`` grounded zmin, ``--short-skids`` the named ground
 supports, ``--float-stack`` the crate-to-crate seat, ``--same-seed`` the
-per-instance variation budget.
+per-instance variation budget, ``--float-nails`` the nail seat,
+``--sharp-iron`` the edge-treatment budget.
 
 Fixed seed 41. DECIMATE COLLAPSE triangle counts are not byte-identical
 across Blender versions — the LOD gate is a ratio band, not an exact
@@ -399,6 +406,32 @@ <h2>Source</h2>
 <span class="c"># The lid bites down onto the rails for the same reason: a lid resting</span>
 <span class="c"># exactly on the rail top shares that plane and those corner vertices.</span>
 LID_BITE = <span class="n">0.004</span>
+<span class="c"># Iron is chamfered like the timber, only finer: a 3.5 mm plate with the</span>
+<span class="c"># timber&#x27;s 1.8 mm bevel would have no flat left.</span>
+IRON_BEVEL = <span class="n">0.0008</span>
+<span class="c"># Clout nails: two per plate, driven through the strap into the post. The</span>
+<span class="c"># shank end sits a named bite below the plate face so each head is seated,</span>
+<span class="c"># not parked on the surface; the head is a frustum so no visible edge of it</span>
+<span class="c"># is a right angle.</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.18</span>, <span class="n">0.82</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>
+<span class="c"># Nail versus plate is told apart by world-AABB extent. Derived from the</span>
+<span class="c"># strap, not the nail: a yawed 10 mm head has an AABB wider than 10 mm, and</span>
+<span class="c"># a fixed 10 mm threshold dropped 8 of 48 nails the moment the heads grew.</span>
+NAIL_EXTENT_MAX = IRON_WRAP * <span class="n">0.5</span>
+FLOAT_NAIL_LIFT = <span class="n">0.0015</span>
+<span class="c"># Edge treatment: no manifold edge on the finished mesh is a right angle.</span>
+<span class="c"># Every box edge is chamfered, so a 90-degree edge means a bevel pass was</span>
+<span class="c"># skipped.</span>
+RIGHT_ANGLE_TOL = math.radians(<span class="n">5.0</span>)
+PLANK_TONE_JITTER = <span class="n">0.30</span>
 BODY_H = <span class="n">0.205</span>
 N_SIDE = <span class="n">3</span>
 N_END = <span class="n">2</span>
@@ -419,18 +452,24 @@ <h2>Source</h2>
 YAW_SPREAD_MIN = <span class="n">0.020</span>
 WIDTH_SPREAD_MIN = <span class="n">0.0008</span>
 
+<span class="c"># Four corners, two plates per corner, one nail per plate per station.</span>
+N_NAILS = N_CRATES * <span class="n">4</span> * <span class="n">2</span> * len(NAIL_ZS)
+
 CRATE_H = SKID_H + BODY_H + SLAT_T - LID_BITE
 STACK_H = N_CRATES * CRATE_H - (N_CRATES - <span class="n">1</span>) * STACK_BITE
 
 BBOX_TOL = <span class="n">0.020</span>
 OUTER_SIZE = (<span class="n">0.658</span>, <span class="n">0.524</span>, <span class="n">0.704</span>)
-<span class="c"># The crate body over its corner iron, measured in the crate&#x27;s own frame.</span>
-BODY_X = CRATE_X + <span class="n">2.0</span> * (IRON_T - IRON_BITE)
-BODY_Y = CRATE_Y + <span class="n">2.0</span> * (IRON_T - IRON_BITE)
+<span class="c"># The crate body over its corner iron and nail heads, in the crate&#x27;s own frame.</span>
+<span class="c"># The strap stands IRON_T - IRON_BITE proud of the post, and each nail</span>
+<span class="c"># head a further NAIL_H - NAIL_BITE proud of the strap.</span>
+BODY_PROUD = IRON_T - IRON_BITE + NAIL_H - NAIL_BITE
+BODY_X = CRATE_X + <span class="n">2.0</span> * BODY_PROUD
+BODY_Y = CRATE_Y + <span class="n">2.0</span> * BODY_PROUD
 CRATE_TOL = <span class="n">0.015</span>
 
-BASE_TRIS_MIN = <span class="n">3200</span>
-BASE_TRIS_MAX = <span class="n">7200</span>
+BASE_TRIS_MIN = <span class="n">5200</span>
+BASE_TRIS_MAX = <span class="n">7000</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>
@@ -443,8 +482,8 @@ <h2>Source</h2>
 COLLIDER_TRIS_MAX = <span class="n">260</span>
 BAKE_RES = <span class="n">256</span>
 CAGE_EXTRUSION = <span class="n">0.08</span>
-METAL_FACES_MIN = <span class="n">120</span>
-WOOD_FACES_MIN = <span class="n">600</span>
+METAL_FACES_MIN = <span class="n">900</span>
+WOOD_FACES_MIN = <span class="n">1800</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>
@@ -561,7 +600,9 @@ <h2>Source</h2>
     <span class="k">return</span> centres, widths
 
 
-<span class="k">def</span> build_crate(bm, base_z, yaw, rng, offset=(<span class="n">0.0</span>, <span class="n">0.0</span>), short_skids=<span class="k">False</span>):
+<span class="k">def</span> build_crate(
+    bm, base_z, yaw, rng, offset=(<span class="n">0.0</span>, <span class="n">0.0</span>), short_skids=<span class="k">False</span>, float_nails=<span class="k">False</span>
+):
     <span class="s">&quot;&quot;&quot;One crate, placed with its skid underside at *base_z* and yawed.
 
     Called once per stack level. Everything that differs between levels
@@ -691,23 +732,88 @@ <h2>Source</h2>
     <span class="c"># Outer face of each plate, after biting into the post.</span>
     px = CRATE_X / <span class="n">2.0</span> + IRON_T - IRON_BITE
     py = CRATE_Y / <span class="n">2.0</span> + IRON_T - IRON_BITE
+    plates = []
     <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>):
-            add_box(
-                bm,
-                (sxn * (px - IRON_T / <span class="n">2.0</span>), syn * (py - IRON_WRAP / <span class="n">2.0</span>), zc),
-                (IRON_T, IRON_WRAP, strap_h),
-                METAL_IDX,
-                xform,
-            )
-            add_box(
-                bm,
-                (sxn * (px - IRON_WRAP / <span class="n">2.0</span>), syn * (py - IRON_T / <span class="n">2.0</span>), zc),
-                (IRON_WRAP, IRON_T, strap_h - <span class="n">2.0</span> * IRON_T),
-                METAL_IDX,
-                xform,
-            )
-    <span class="k">return</span> wood, side_w
+            plates.extend(add_strap(bm, sxn, syn, px, py, strap_z0, strap_h, xform))
+    <span class="c"># Nails are placed from the plate&#x27;s own outer face and normal, so they</span>
+    <span class="c"># follow the strap if its thickness, bite or wrap ever changes.</span>
+    nail_stations = []
+    <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>):
+            <span class="k">for</span> fz <span class="k">in</span> NAIL_ZS:
+                z = strap_z0 + strap_h * fz
+                nail_stations.append(
+                    (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>)))
+                )
+                nail_stations.append(
+                    (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>)))
+                )
+    <span class="k">for</span> face_pt, nrm <span class="k">in</span> nail_stations:
+        add_nail(bm, face_pt, nrm, xform, lift=FLOAT_NAIL_LIFT <span class="k">if</span> float_nails <span class="k">else</span> <span class="n">0.0</span>)
+    <span class="k">return</span> wood, side_w, plates
+
+
+<span class="k">def</span> add_strap(bm, sxn, syn, px, py, z0, h, xform):
+    <span class="s">&quot;&quot;&quot;One L-section corner strap, a single closed shell.
+
+    Two overlapping boxes shared their outer corner edge, so once the iron
+    was chamfered both boxes put a strip on the same line: a coplanar pair
+    at every corner. An extruded L has one outer corner. Each cap is two
+    convex quads meeting on the inner-corner diagonal, so there is no n-gon.
+    &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 = []
+    <span class="k">for</span> z <span class="k">in</span> (z0, z0 + h):
+        rings.append(
+            [bm.verts.new(xform @ Vector((sxn * x, syn * y, z))) <span class="k">for</span> x, y <span class="k">in</span> outline]
+        )
+    lo, hi = rings
+    faces = []
+    <span class="c"># Bottom cap wound opposite the top so the shell is consistently</span>
+    <span class="c"># oriented; recalc_face_normals later points it outward.</span>
+    <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))
+    n = len(outline)
+    <span class="k">for</span> i <span class="k">in</span> range(n):
+        j = (i + <span class="n">1</span>) % n
+        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, xform, lift=<span class="n">0.0</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()
+    seat = Matrix.Translation(face_pt + nrm * lift) @ 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)
+    )
+    verts = geo[<span class="s">&quot;verts&quot;</span>]
+    <span class="k">for</span> v <span class="k">in</span> verts:
+        v.co = xform @ (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> verts <span class="k">for</span> f <span class="k">in</span> v.link_faces}:
+        f.material_index = METAL_IDX
 
 
 <span class="k">def</span> build_stack_mesh(
@@ -715,9 +821,12 @@ <h2>Source</h2>
     same_seed=<span class="k">False</span>,
     short_skids=<span class="k">False</span>,
     float_stack=<span class="k">False</span>,
+    float_nails=<span class="k">False</span>,
+    sharp_iron=<span class="k">False</span>,
 ):
     bm = bmesh.new()
     wood_verts = []
+    plate_verts = []
     <span class="k">try</span>:
         base_z = <span class="n">0.0</span>
         <span class="k">for</span> i <span class="k">in</span> range(N_CRATES):
@@ -736,17 +845,41 @@ <h2>Source</h2>
                 <span class="n">0.0</span> <span class="k">if</span> i == <span class="n">0</span> <span class="k">else</span> place.uniform(-OFFSET_MAX, OFFSET_MAX),
             )
             lift = FLOAT_LIFT <span class="k">if</span> (float_stack <span class="k">and</span> i == N_CRATES - <span class="n">1</span>) <span class="k">else</span> <span class="n">0.0</span>
-            verts, _widths = build_crate(
+            verts, _widths, plates = build_crate(
                 bm,
                 base_z + lift,
                 yaw,
                 rng,
                 offset=offset,
                 short_skids=short_skids <span class="k">and</span> i == <span class="n">0</span>,
+                float_nails=float_nails,
             )
             wood_verts.extend(verts)
+            plate_verts.extend(plates)
             base_z += CRATE_H - STACK_BITE
 
+        <span class="c"># Iron first, at its own finer offset: the plates are only 3.5 mm</span>
+        <span class="c"># thick. The nails are frustums and need no bevel.</span>
+        <span class="c"># The flat diagonal inside each L cap is not an edge anyone sees,</span>
+        <span class="c"># and chamfering it would crease a flat face.</span>
+        <span class="k">if</span> plate_verts <span class="k">and</span> <span class="k">not</span> sharp_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> plate_verts <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="c"># material= pins the chamfer faces to iron; left to default,</span>
+            <span class="c"># bevel handed them slot 0 and the plates rendered as timber.</span>
+            bmesh.ops.bevel(
+                bm,
+                geom=edges,
+                offset=IRON_BEVEL,
+                segments=<span class="n">1</span>,
+                profile=<span class="n">0.5</span>,
+                affect=<span class="s">&quot;EDGES&quot;</span>,
+                clamp_overlap=<span class="k">True</span>,
+                material=METAL_IDX,
+            )
+
         <span class="k">if</span> wood_verts:
             edges = list({e <span class="k">for</span> v <span class="k">in</span> wood_verts <span class="k">for</span> e <span class="k">in</span> v.link_edges <span class="k">if</span> v.is_valid})
             <span class="k">if</span> edges:
@@ -774,11 +907,40 @@ <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> paint_planks(me):
+    <span class="s">&quot;&quot;&quot;Per-plank tone and grain direction, as face attributes.
+
+    Every plank came out of one material, so every plank was the same
+    board. Each shell gets a seeded tone and the direction it runs in —
+    its long axis, recovered from its own vertices — which the wood shader
+    uses to stretch its grain along the board rather than along a world
+    axis that is 6 degrees off on a yawed crate.
+    &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)
+    vf = vert_faces(me)
+    rng = random.Random(STACK_SEED * <span class="n">13</span>)
+    <span class="k">for</span> g <span class="k">in</span> shells(me):
+        pts = [me.vertices[i].co <span class="k">for</span> i <span class="k">in</span> g]
+        e1, _e2, theta = xy_principal(pts)
+        dz = max(p.z <span class="k">for</span> p <span class="k">in</span> pts) - min(p.z <span class="k">for</span> p <span class="k">in</span> pts)
+        d = (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">1.0</span>) <span class="k">if</span> dz &gt; e1 <span class="k">else</span> (math.cos(theta), math.sin(theta), <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> fi <span class="k">in</span> {fi <span class="k">for</span> i <span class="k">in</span> g <span class="k">for</span> fi <span class="k">in</span> vf[i]}:
+            tone[fi] = t
+            grain[fi] = d
+    a = me.attributes.new(<span class="s">&quot;PlankTone&quot;</span>, <span class="s">&quot;FLOAT&quot;</span>, <span class="s">&quot;FACE&quot;</span>)
+    a.data.foreach_set(<span class="s">&quot;value&quot;</span>, tone)
+    b = me.attributes.new(<span class="s">&quot;GrainDir&quot;</span>, <span class="s">&quot;FLOAT_VECTOR&quot;</span>, <span class="s">&quot;FACE&quot;</span>)
+    b.data.foreach_set(<span class="s">&quot;vector&quot;</span>, [c <span class="k">for</span> v <span class="k">in</span> grain <span class="k">for</span> c <span class="k">in</span> v])
+
+
 <span class="k">def</span> principled(name, color, metallic, roughness, noise_scale=<span class="n">0.0</span>, wear=<span class="k">None</span>):
     mat = bpy.data.materials.new(name)
     mat.use_nodes = <span class="k">True</span>
@@ -809,6 +971,92 @@ <h2>Source</h2>
     <span class="k">return</span> mat
 
 
+<span class="k">def</span> _sock(sockets, identifier):
+    <span class="s">&quot;&quot;&quot;A Mix-node socket by identifier; its A/B/Result names repeat per type.&quot;&quot;&quot;</span>
+    <span class="k">return</span> next(s <span class="k">for</span> s <span class="k">in</span> sockets <span class="k">if</span> s.identifier == identifier)
+
+
+<span class="k">def</span> wood_material(name):
+    <span class="s">&quot;&quot;&quot;Timber whose grain runs along each board and whose tone varies by plank.
+
+    Reads the ``PlankTone`` and ``GrainDir`` face attributes that
+    ``paint_planks`` writes. The grain is noise sampled in object space with
+    the component along the board compressed, so its streaks are long in
+    the direction the plank runs whatever the crate&#x27;s yaw.
+    &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>]
+    bsdf.inputs[<span class="s">&quot;Metallic&quot;</span>].default_value = <span class="n">0.0</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>])
+    <span class="c"># Plank tone also offsets the grain sample, so neighbouring boards do</span>
+    <span class="c"># not show one continuous figure across the gap between them.</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">34.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.105</span>, <span class="n">0.045</span>, <span class="n">0.016</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.34</span>, <span class="n">0.16</span>, <span class="n">0.060</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.2</span>
+    gain.inputs[<span class="n">2</span>].default_value = <span class="n">0.40</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> stack_materials():
+    <span class="s">&quot;&quot;&quot;(wood, iron) — shared by the check path, the render and inspection.&quot;&quot;&quot;</span>
+    wood = wood_material(<span class="s">&quot;StackWood&quot;</span>)
+    metal = principled(
+        <span class="s">&quot;StackMetal&quot;</span>, (<span class="n">0.17</span>, <span class="n">0.165</span>, <span class="n">0.155</span>, <span class="n">1.0</span>), <span class="n">0.80</span>, <span class="n">0.46</span>,
+        noise_scale=<span class="n">18.0</span>, wear=(<span class="n">0.20</span>, <span class="n">0.085</span>, <span class="n">0.032</span>, <span class="n">1.0</span>),
+    )
+    <span class="k">return</span> wood, metal
+
+
 <span class="k">def</span> assign_slots(obj, wood, metal):
     mats = obj.data.materials
     <span class="k">for</span> i, mat <span class="k">in</span> enumerate((wood, metal)):
@@ -1276,6 +1524,78 @@ <h2>Source</h2>
     <span class="k">return</span> out
 
 
+<span class="k">def</span> right_angle_edges(me):
+    <span class="s">&quot;&quot;&quot;Manifold edges whose two faces meet at 90 degrees, iron and timber.
+
+    Every box in the piece is chamfered, and a one-segment chamfer turns a
+    90-degree edge into two 45-degree ones. An edge still at 90 is one a
+    bevel pass skipped: the razor edge that renders as a hard black line.
+    &quot;&quot;&quot;</span>
+    counts = {WOOD_IDX: <span class="n">0</span>, METAL_IDX: <span class="n">0</span>}
+    bm = bmesh.new()
+    <span class="k">try</span>:
+        bm.from_mesh(me)
+        <span class="k">for</span> e <span class="k">in</span> bm.edges:
+            <span class="k">if</span> len(e.link_faces) != <span class="n">2</span>:
+                <span class="k">continue</span>
+            <span class="k">if</span> abs(e.calc_face_angle(<span class="n">0.0</span>) - math.pi / <span class="n">2.0</span>) &lt;= RIGHT_ANGLE_TOL:
+                idx = e.link_faces[<span class="n">0</span>].material_index
+                counts[idx] = counts.get(idx, <span class="n">0</span>) + <span class="n">1</span>
+    <span class="k">finally</span>:
+        bm.free()
+    <span class="k">return</span> counts
+
+
+<span class="k">def</span> nail_audit(me):
+    <span class="s">&quot;&quot;&quot;Seat of every nail head in its strap, measured against the plate.
+
+    Nails are the small iron shells; plates are the rest. Each nail vertex
+    gets a signed distance to the plate surface (negative inside). The
+    deepest is the bite, which must sit in a band — not parked on the plate
+    and not sunk through it — and the highest is how proud the head
+    stands, which must be enough to catch light.
+    &quot;&quot;&quot;</span>
+    vf = vert_faces(me)
+    nails, plates = [], []
+    <span class="k">for</span> g <span class="k">in</span> shells(me):
+        <span class="k">if</span> mat_of(me, g, vf) != METAL_IDX:
+            <span class="k">continue</span>
+        lo_hi = shell_aabb(me, g)
+        ext = max(lo_hi[<span class="n">3</span>] - lo_hi[<span class="n">0</span>], lo_hi[<span class="n">4</span>] - lo_hi[<span class="n">1</span>], lo_hi[<span class="n">5</span>] - lo_hi[<span class="n">2</span>])
+        (nails <span class="k">if</span> ext &lt; NAIL_EXTENT_MAX <span class="k">else</span> plates).append(g)
+    <span class="k">if</span> <span class="k">not</span> nails <span class="k">or</span> <span class="k">not</span> plates:
+        <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 = set()
+        <span class="k">for</span> g <span class="k">in</span> plates:
+            keep.update(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)
+            <span class="k">if</span> loc <span class="k">is</span> <span class="k">None</span>:
+                signed.append(<span class="n">99.0</span>)
+                <span class="k">continue</span>
+            signed.append((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> add_stray_vert(me):
     bm = bmesh.new()
     <span class="k">try</span>:
@@ -1382,24 +1702,21 @@ <h2>Source</h2>
     short_skids=<span class="k">False</span>,
     float_stack=<span class="k">False</span>,
     same_seed=<span class="k">False</span>,
+    float_nails=<span class="k">False</span>,
+    sharp_iron=<span class="k">False</span>,
 ):
     bpy.ops.wm.read_factory_settings(use_empty=<span class="k">True</span>)
     flags = dict(
         same_seed=same_seed,
         short_skids=short_skids,
         float_stack=float_stack,
+        float_nails=float_nails,
+        sharp_iron=sharp_iron,
     )
     nothing = (<span class="k">None</span>,) * <span class="n">5</span>
     low = build_stack_mesh(<span class="s">&quot;StackLow&quot;</span>, **flags)
     high = build_stack_mesh(<span class="s">&quot;StackHigh&quot;</span>, **flags)
-    wood = principled(
-        <span class="s">&quot;StackWood&quot;</span>, (<span class="n">0.40</span>, <span class="n">0.18</span>, <span class="n">0.065</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.55</span>,
-        noise_scale=<span class="n">9.0</span>, wear=(<span class="n">0.20</span>, <span class="n">0.085</span>, <span class="n">0.030</span>, <span class="n">1.0</span>),
-    )
-    metal = principled(
-        <span class="s">&quot;StackMetal&quot;</span>, (<span class="n">0.20</span>, <span class="n">0.19</span>, <span class="n">0.180</span>, <span class="n">1.0</span>), <span class="n">0.88</span>, <span class="n">0.33</span>,
-        noise_scale=<span class="n">6.0</span>, wear=(<span class="n">0.10</span>, <span class="n">0.095</span>, <span class="n">0.088</span>, <span class="n">1.0</span>),
-    )
+    wood, metal = stack_materials()
     assign_slots(low, wood, metal)
     assign_slots(high, wood, metal)
     <span class="k">if</span> stray_vert:
@@ -1449,11 +1766,17 @@ <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)
     st = stack_audit(low.data)
     crates = crate_size_audit(low.data, st[<span class="s">&#x27;yaws&#x27;</span>], st[<span class="s">&#x27;bases&#x27;</span>])
+    nails = nail_audit(low.data)
+    right = right_angle_edges(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(<span class="s">f&quot;</span><span class="s">measured mat_index_counts=</span>{idx_counts}<span class="s">&quot;</span>)
@@ -1493,6 +1816,12 @@ <h2>Source</h2>
         <span class="s">&quot;measured crate_footprints=&quot;</span>
         <span class="s">f&quot;</span>{[(round(c[<span class="n">0</span>], <span class="n">4</span>), round(c[<span class="n">1</span>], <span class="n">4</span>)) <span class="k">for</span> c <span class="k">in</span> crates]}<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">right_angle_edges wood=</span>{right.get(WOOD_IDX, <span class="n">0</span>)}<span class="s"> </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">iron=</span>{right.get(METAL_IDX, <span class="n">0</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(
@@ -1566,6 +1895,19 @@ <h2>Source</h2>
             <span class="s">f&quot;</span><span class="s">stack seat gap </span>{st[<span class="s">&#x27;seat&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> &gt; </span>{STACK_SEAT_MAX}<span class="s"> over </span><span class="s">&quot;</span>
             <span class="s">f&quot;</span>{st[<span class="s">&#x27;seats&#x27;</span>]}<span class="s"> seats (--float-stack is the designed fail)</span><span class="s">&quot;</span>, <span class="n">18</span>
         ),) + nothing
+    <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>
+        ),) + nothing
     <span class="k">for</span> i, (cx, cy) <span class="k">in</span> enumerate(crates):
         <span class="k">if</span> abs(cx - BODY_X) &gt; CRATE_TOL <span class="k">or</span> abs(cy - BODY_Y) &gt; CRATE_TOL:
             <span class="k">return</span> (fail(
@@ -1583,6 +1925,12 @@ <h2>Source</h2>
             <span class="s">f&quot;</span><span class="s">(min </span>{WIDTH_SPREAD_MIN}<span class="s">) — the three crates are copies, not </span><span class="s">&quot;</span>
             <span class="s">&quot;instances (--same-seed is the designed fail)&quot;</span>, <span class="n">20</span>
         ),) + nothing
+    <span class="k">if</span> sum(right.values()):
+        <span class="k">return</span> (fail(
+            <span class="s">f&quot;</span><span class="s">right-angle edges wood=</span>{right.get(WOOD_IDX, <span class="n">0</span>)}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">f&quot;</span><span class="s">iron=</span>{right.get(METAL_IDX, <span class="n">0</span>)}<span class="s">: a chamfer pass was skipped </span><span class="s">&quot;</span>
+            <span class="s">&quot;(--sharp-iron is the designed fail)&quot;</span>, <span class="n">21</span>
+        ),) + nothing
     <span class="k">return</span> <span class="n">0</span>, low, high, wood, tex, collider
 
 
@@ -1704,6 +2052,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-stack&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
     p.add_argument(<span class="s">&quot;--same-seed&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;--sharp-iron&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
     args = p.parse_args(argv)
 
     code, low, _high, wood, tex, _col = check(
@@ -1713,6 +2063,8 @@ <h2>Source</h2>
         short_skids=args.short_skids,
         float_stack=args.float_stack,
         same_seed=args.same_seed,
+        float_nails=args.float_nails,
+        sharp_iron=args.sharp_iron,
     )
     <span class="k">if</span> code:
         <span class="k">return</span> code
@@ -1737,7 +2089,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/crate-stack-hero.webp" alt="Three wooden shipping crates stacked, each turned slightly differently." />
+    <img src="../assets/crate-stack-hero.webp" alt="Three grained wooden shipping crates stacked, each turned slightly differently, with nailed iron corner straps." />
   </dialog>
   <footer>
     <div class="statusbar">
diff --git a/docs/gallery/depsgraph-export/index.html b/docs/gallery/depsgraph-export/index.html
index 59b245fc..b661f7da 100644
--- a/docs/gallery/depsgraph-export/index.html
+++ b/docs/gallery/depsgraph-export/index.html
@@ -16,13 +16,13 @@
   <meta property="og:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/depsgraph-export-hero.webp" />
   <meta property="og:image:width" content="1280" />
   <meta property="og:image:height" content="720" />
-  <meta property="og:image:alt" content="A teal cube beside a slightly faceted teal sphere on a dark studio floor." />
+  <meta property="og:image:alt" content="A teal cube outlined by its twelve edges beside a faceted teal sphere covered in a dense pale wire grid, on a dark studio floor." />
   <meta property="og:site_name" content="Blender Developer Tools" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="depsgraph-export — Examples — Blender Developer Tools" />
   <meta name="twitter:description" content="The depsgraph lifetime contract — evaluated_get().to_mesh() paired with to_mesh_clear() — measured against an OBJ export of the same object." />
   <meta name="twitter:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/depsgraph-export-hero.webp" />
-  <meta name="twitter:image:alt" content="A teal cube beside a slightly faceted teal sphere on a dark studio floor." />
+  <meta name="twitter:image:alt" content="A teal cube outlined by its twelve edges beside a faceted teal sphere covered in a dense pale wire grid, on a dark studio floor." />
   <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>depsgraph-export</h1>
     <p>The depsgraph lifetime contract — evaluated_get().to_mesh() paired with to_mesh_clear() — measured against an OBJ export of the same object.</p>
   </header>
   <main id="main">
-    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: A teal cube beside a slightly faceted teal sphere on a dark studio floor.">
-      <img src="../assets/depsgraph-export-hero.webp" alt="A teal cube beside a slightly faceted teal sphere on a dark studio floor." width="1280" height="720" />
+    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: A teal cube outlined by its twelve edges beside a faceted teal sphere covered in a dense pale wire grid, on a dark studio floor.">
+      <img src="../assets/depsgraph-export-hero.webp" alt="A teal cube outlined by its twelve edges beside a faceted teal sphere covered in a dense pale wire grid, on a dark studio floor." 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> Exports ship evaluated geometry: the exported vertex count equals the subsurf-applied count and is strictly greater than the base mesh.</div>
@@ -431,6 +431,28 @@ <h2>Source</h2>
     <span class="k">for</span> poly <span class="k">in</span> obj.data.polygons:
         poly.use_smooth = <span class="k">True</span>
 
+    <span class="c"># Edge cages over both: the check compares vertex counts, and two teal</span>
+    <span class="c"># silhouettes alone read as &quot;a cube and a ball&quot;. The base cage shows the</span>
+    <span class="c"># 8 verts the datablock holds; the evaluated cage is the same SUBSURF</span>
+    <span class="c"># followed by WIREFRAME, so it draws exactly the edges the OBJ ships.</span>
+    <span class="c"># Render-path scaffolding only: separate objects, added after check().</span>
+    cage_mat = principled(<span class="s">&quot;Cage&quot;</span>, (<span class="n">0.92</span>, <span class="n">0.80</span>, <span class="n">0.56</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.35</span>)
+    cages = []
+    <span class="k">for</span> src, subsurf <span class="k">in</span> ((base_obj, <span class="k">False</span>), (obj, <span class="k">True</span>)):
+        cage = bpy.data.objects.new(src.name + <span class="s">&quot;Cage&quot;</span>, obj.data.copy())
+        cage.data.materials.clear()
+        cage.data.materials.append(cage_mat)
+        cage.location = src.location
+        cage.rotation_euler = src.rotation_euler
+        <span class="k">if</span> subsurf:
+            cage.modifiers.new(<span class="s">&quot;ss&quot;</span>, <span class="s">&#x27;SUBSURF&#x27;</span>).levels = <span class="n">2</span>
+        wire = cage.modifiers.new(<span class="s">&quot;cage&quot;</span>, <span class="s">&#x27;WIREFRAME&#x27;</span>)
+        wire.thickness = <span class="n">0.035</span> <span class="k">if</span> <span class="k">not</span> subsurf <span class="k">else</span> <span class="n">0.018</span>
+        wire.offset = <span class="n">1.0</span>  <span class="c"># grow outward so the lines sit on the surface</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>:
@@ -505,7 +527,7 @@ <h2>Source</h2>
     fcode = gallery_framing.check_framing(
         scene, cam,
         hero=[base_obj, obj],
-        elements=[base_obj, obj],
+        elements=[base_obj, obj] + cages,
         stage=[floor, wall],
     )
     <span class="k">if</span> fcode:
@@ -554,7 +576,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/depsgraph-export-hero.webp" alt="A teal cube beside a slightly faceted teal sphere on a dark studio floor." />
+    <img src="../assets/depsgraph-export-hero.webp" alt="A teal cube outlined by its twelve edges beside a faceted teal sphere covered in a dense pale wire grid, on a dark studio floor." />
   </dialog>
   <footer>
     <div class="statusbar">
diff --git a/docs/gallery/index.html b/docs/gallery/index.html
index 7300cee3..f8682207 100644
--- a/docs/gallery/index.html
+++ b/docs/gallery/index.html
@@ -376,7 +376,7 @@ <h2><a href="gn-sdf-remesh/">gn-sdf-remesh</a></h2>
       </article>
       <article class="card" data-tags="depsgraph export">
         <a class="card-media" href="depsgraph-export/" tabindex="-1" aria-hidden="true">
-          <img src="assets/depsgraph-export-hero.webp" alt="A teal cube beside a slightly faceted teal sphere on a dark studio floor." loading="lazy" decoding="async" />
+          <img src="assets/depsgraph-export-hero.webp" alt="A teal cube outlined by its twelve edges beside a faceted teal sphere covered in a dense pale wire grid, on a dark studio floor." loading="lazy" decoding="async" />
         </a>
         <div class="card-body">
           <h2><a href="depsgraph-export/">depsgraph-export</a></h2>
@@ -1190,7 +1190,7 @@ <h2><a href="hay-bale/">hay-bale</a></h2>
       </article>
       <article class="card" data-tags="mesh export showcase">
         <a class="card-media" href="crate-stack/" tabindex="-1" aria-hidden="true">
-          <img src="assets/crate-stack-hero.webp" alt="Three wooden shipping crates stacked, each turned slightly differently." loading="lazy" decoding="async" />
+          <img src="assets/crate-stack-hero.webp" alt="Three grained wooden shipping crates stacked, each turned slightly differently, with nailed iron corner straps." loading="lazy" decoding="async" />
         </a>
         <div class="card-body">
           <h2><a href="crate-stack/">crate-stack</a></h2>
diff --git a/examples/depsgraph-export/depsgraph_export.py b/examples/depsgraph-export/depsgraph_export.py
index b3cd1ebc..24447baa 100644
--- a/examples/depsgraph-export/depsgraph_export.py
+++ b/examples/depsgraph-export/depsgraph_export.py
@@ -123,6 +123,28 @@ def render_still(obj, path, engine):
     for poly in obj.data.polygons:
         poly.use_smooth = True
 
+    # Edge cages over both: the check compares vertex counts, and two teal
+    # silhouettes alone read as "a cube and a ball". The base cage shows the
+    # 8 verts the datablock holds; the evaluated cage is the same SUBSURF
+    # followed by WIREFRAME, so it draws exactly the edges the OBJ ships.
+    # Render-path scaffolding only: separate objects, added after check().
+    cage_mat = principled("Cage", (0.92, 0.80, 0.56, 1.0), 0.0, 0.35)
+    cages = []
+    for src, subsurf in ((base_obj, False), (obj, True)):
+        cage = bpy.data.objects.new(src.name + "Cage", obj.data.copy())
+        cage.data.materials.clear()
+        cage.data.materials.append(cage_mat)
+        cage.location = src.location
+        cage.rotation_euler = src.rotation_euler
+        if subsurf:
+            cage.modifiers.new("ss", 'SUBSURF').levels = 2
+        wire = cage.modifiers.new("cage", 'WIREFRAME')
+        wire.thickness = 0.035 if not subsurf else 0.018
+        wire.offset = 1.0  # grow outward so the lines sit on the surface
+        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:
@@ -197,7 +219,7 @@ def light(name, loc, energy, size, col, rot):
     fcode = gallery_framing.check_framing(
         scene, cam,
         hero=[base_obj, obj],
-        elements=[base_obj, obj],
+        elements=[base_obj, obj] + cages,
         stage=[floor, wall],
     )
     if fcode:
diff --git a/examples/depsgraph-export/preview.webp b/examples/depsgraph-export/preview.webp
index a36165cf..5bc5aad1 100644
Binary files a/examples/depsgraph-export/preview.webp and b/examples/depsgraph-export/preview.webp differ
diff --git a/examples/gallery.json b/examples/gallery.json
index 02bd5637..40322804 100644
--- a/examples/gallery.json
+++ b/examples/gallery.json
@@ -47,7 +47,7 @@
       "name": "depsgraph-export",
       "dir": "examples/depsgraph-export",
       "teaches": "The depsgraph lifetime contract — evaluated_get().to_mesh() paired with to_mesh_clear() — measured against an OBJ export of the same object.",
-      "alt": "A teal cube beside a slightly faceted teal sphere on a dark studio floor.",
+      "alt": "A teal cube outlined by its twelve edges beside a faceted teal sphere covered in a dense pale wire grid, on a dark studio floor.",
       "witnessesFix": "Exports ship evaluated geometry: the exported vertex count equals the subsurf-applied count and is strictly greater than the base mesh.",
       "hero": "docs/gallery/assets/depsgraph-export-hero.webp",
       "preview": "examples/depsgraph-export/preview.webp",
diff --git a/examples/unapplied-scale-gltf/README.md b/examples/unapplied-scale-gltf/README.md
index 879b724b..7195f999 100644
--- a/examples/unapplied-scale-gltf/README.md
+++ b/examples/unapplied-scale-gltf/README.md
@@ -7,22 +7,67 @@ node has no scale) and neighbor of
 [`prop-origin-transform`](../prop-origin-transform/) (bake to `(1,1,1)`
 in Blender).
 
-**Why this pathology:** `export_apply` RNA is "Apply modifiers … to mesh
-objects". AI code treats it as "apply object transforms". Unapplied
-scale lands on the glTF node, Y-up permuted; POSITION stays local.
+## The contract
+
+`bpy.ops.export_scene.gltf(export_apply=True)` applies **modifiers**, not
+object transforms. Its RNA description, identical on 4.5.11, 5.1.2 and
+5.2.1, reads:
+
+> Apply modifiers (excluding Armatures) to mesh objects -WARNING: prevents
+> exporting shape keys
+
+An object whose `Object.scale` was never applied therefore exports with
+that scale on the glTF **node** (`nodes[i].scale`), permuted to Y-up, and
+with its **POSITION** accessor still holding the unscaled local
+coordinates. `export_apply` has no effect on either: exporting the same
+object with `export_apply=False` writes the identical node scale and
+POSITION range.
+
+**Who hits this:** a pipeline that sets `export_apply=True` believing it
+bakes transforms, then ships a prop whose root carries a non-uniform
+scale. In the engine the mesh looks the right size, but any child
+rotated under that node skews, physics colliders sized from the mesh
+bounds come out at the local size, and a script reading the node's
+scale gets `(2, 0.5, 1)` instead of `(1, 1, 1)`. The fix is to apply
+scale in Blender before export (`bpy.ops.object.transform_apply(scale=True)`,
+or the data-API bake in `prop-origin-transform`), not an exporter flag.
+
+## What the check asserts
 
 **Pre-assertion (pathology exists):** `obj.scale == (2, 1, 0.5)`
 (non-uniform) **and** local verts at ±1 on every axis. `--identity`
-exits 3.
+leaves the scale at `(1, 1, 1)` and exits 3.
+
+**Handling (second axis):** read back from the written `.gltf` and its
+`.bin`, not from Blender state:
+
+- `nodes[0].scale == [2, 0.5, 1]` — Blender `(sx, sy, sz)` becomes glTF
+  `(sx, sz, sy)` under the Y-up conversion `(x, y, z) → (x, z, −y)`.
+- POSITION min/max is ±1 on every axis — the local cube, unscaled.
+- POSITION count is 8 either way, so a vertex count alone cannot tell
+  applied from unapplied. The node scale and the POSITION range are the
+  witnesses.
+
+`--bake` applies the scale to the mesh data after the pre-assertion.
+The node then has no `scale` key and POSITION spans x ±2, y ±0.5, z ±1,
+so the check exits 4.
+
+## Versions
+
+Re-verified on Blender 4.5.11 LTS, 5.1.2 and 5.2.1 LTS: the RNA
+description, the node scale, the POSITION range and both falsifier exits
+are the same on all three. Not a version split.
 
-**Handling (second axis):** with `export_apply=True`, node.scale is
-`(2, 0.5, 1)` (`(sx, sz, sy)` from `(x,y,z)→(x,z,−y)`) and POSITION
-bbox stays ±1. Vert count is 8 either way. `--bake` after the
-pre-assert exits 4 (node.scale missing, POSITION x ±2).
+No gallery still. A stretched box looks like modeled non-uniform size;
+the defect is unapplied versus baked, which only the file shows.
 
-Same on 4.5 LTS and 5.2 LTS. Not a version split.
+## API reference
 
-No gallery still. A stretched box looks like modeled non-uniform size.
+- [`bpy.ops.export_scene.gltf`](https://docs.blender.org/api/current/bpy.ops.export_scene.html#bpy.ops.export_scene.gltf)
+  ([4.5 LTS](https://docs.blender.org/api/4.5/bpy.ops.export_scene.html#bpy.ops.export_scene.gltf))
+  — `export_apply`, `export_yup`
+- [`Object.scale`](https://docs.blender.org/api/current/bpy.types.Object.html#bpy.types.Object.scale)
+- [glTF 2.0 node transforms](https://registry.khronos.org/glTF/specs/2.0/glTF-2.0.html#transformations)
 
 ## Run
 
diff --git a/showcase/README.md b/showcase/README.md
index 171ea882..1b489db6 100644
--- a/showcase/README.md
+++ b/showcase/README.md
@@ -50,6 +50,9 @@ entry in `showcase/gallery.json`, and a rendered still.
   `--skew-wheel` / `--turn-posts` break a mirror or placement budget
   (exit 19). `--float-rivets` lifts fasteners off their host (exit 18).
   `--round-haft` turns an oval section round (exit 19).
+  `--float-nails` lifts nail heads off their strap (exit 18).
+  `--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:
   prove each one fails once, and check the exit code, not just
   non-zero.
@@ -299,6 +302,34 @@ entry in `showcase/gallery.json`, and a rendered still.
   because the log's wobble drops the surface 1.4 mm across one head.
   Aimed down the normal both seat at 1.50–1.54 mm. `--float-rivets` is
   the falsifier.
+- **Edge treatment: no right angles (file-local code).** Real objects
+  have chamfers that catch light. Where every box in a piece is
+  chamfered, count manifold edges whose faces meet within 5° of 90° and
+  assert **0** — a one-segment chamfer turns every 90° edge into two 45°
+  ones, so a survivor is a bevel pass that was skipped. Chamfer thin
+  stock at its own offset: `crate-stack`'s 3.5 mm iron takes 0.8 mm,
+  where the timber's 1.8 mm would leave no flat. Pass `material=` to
+  `bmesh.ops.bevel`: left at its default the chamfer faces took slot 0,
+  and the iron plates rendered — and were classified — as timber.
+  `--sharp-iron` is the falsifier. 15–19 are reserved, so the code is
+  the piece's next free one.
+- **An L-section is one shell, not two boxes (exit 15).** Two
+  overlapping boxes for the legs of an angle strap share the outer
+  corner edge; chamfer them and both lay a strip on the same line — a
+  coplanar cross-shell pair at every corner (`crate-stack`: 12). Extrude
+  the L profile once, each cap as two convex quads meeting on the
+  inner-corner diagonal, and skip that flat diagonal in the bevel.
+- **Classify small parts by a size derived from the host.** A nail,
+  rivet or stud told apart from its plate by world-AABB extent needs a
+  threshold taken from the plate (`IRON_WRAP * 0.5`), not from the
+  fastener: a yawed 10 mm head has a world AABB wider than 10 mm, and a
+  fixed 10 mm threshold silently dropped 8 of 48 nails.
+- **Identical boards read as CG.** Planks cut from one material are one
+  plank repeated. Give each shell a seeded tone and its own grain
+  direction — its long axis, recovered from its vertices — as face
+  attributes, and have the shader stretch its grain along that axis
+  rather than a world axis, which a yawed member is off by its yaw.
+  Nothing here is an assertion; it is found on the inspection sheet.
 - **A section that carries the read is a budget (exit 19).** Where a
   cross-section is what makes a part recognisable — an axe handle is
   oval, a broom handle is round — assert it as a ratio band at a named
diff --git a/showcase/crate-stack/README.md b/showcase/crate-stack/README.md
index 166d9069..ffa9d577 100644
--- a/showcase/crate-stack/README.md
+++ b/showcase/crate-stack/README.md
@@ -14,7 +14,7 @@ then the shipped pipeline:
 | Shipped content | Used for |
 | --- | --- |
 | `skills/mesh-editing-and-bmesh` | box, bevel and UV construction in one `bmesh` |
-| `skills/procedural-materials-and-shaders` | two Principled materials with noise-driven wear |
+| `skills/procedural-materials-and-shaders` | attribute-driven timber (per-plank tone, grain along each board) and rusted iron |
 | `skills/bake-high-to-low` | Cycles tangent-space normal bake, high onto low |
 | `skills/engine-export-presets` | Unity glTF (`export_yup=True`) |
 | `skills/depsgraph-and-evaluated-data` | evaluated triangle counts for the LOD ratios |
@@ -49,28 +49,30 @@ for the 4.5.11 / 5.1.2 figures.
 
 | Budget | Band | Measured |
 | --- | --- | --- |
-| Base triangles | 3200–7200 | 4380 |
+| Base triangles | 5200–7000 | 6060 |
 | LOD1 ratio | 0.32–0.62 | 0.5000 |
-| LOD2 ratio | 0.10–0.35 | 0.2005 (5.2) / 0.2199 (4.5, 5.1) |
+| LOD2 ratio | 0.10–0.35 | 0.2198 |
 | Material slots | exactly 2, distinct | 2 |
-| Iron faces | ≥ 120 | 216 |
-| Timber faces | ≥ 600 | 2436 |
-| UV bounds | inside 0..1 | (0.0008, 0.0008)–(0.9992, 0.9992) |
+| Iron faces | ≥ 900 | 1344 |
+| Timber faces | ≥ 1800 | 2418 |
+| UV bounds | inside 0..1 | (0.0006, 0.0007)–(0.9994, 0.9993) |
 | UV AABB overlap | ≤ 1e-5 | 0.000000 |
-| Outer AABB | 0.658 × 0.524 × 0.704 m ± 0.020 | 0.6582 × 0.5235 × 0.7040 |
-| Crate body footprint | 0.585 × 0.425 m ± 0.015, in the crate's own frame | 0.5846 × 0.4246 (all three) |
-| Collider triangles | ≤ 260 | 202 |
+| Outer AABB | 0.658 × 0.524 × 0.704 m ± 0.020 | 0.6583 × 0.5235 × 0.7040 |
+| Crate body footprint | 0.588 × 0.428 m ± 0.015, in the crate's own frame | 0.5882 × 0.4282 (all three) |
+| Collider triangles | ≤ 260 | 230 |
 | Normal bake | `{'FINISHED'}` with image data | `{'FINISHED'}`, `has_data=True` |
-| glTF export | file written, non-empty | ~340 kB |
+| glTF export | file written, non-empty | ~490 kB |
 | Hygiene | all zero | loose 0/0, non-manifold 0, zero-area 0, doubles 0, n-gons 0, coplanar disjoint pairs 0 |
 | Grounded AABB | \|zmin\| ≤ 1e-4 | 0.00000 |
 | Ground runners | 3 named supports, each zmin ≤ 1e-3 | 3 at 0.00000 |
 | Crate-to-crate seat | both seats, surface gap ≤ 0.0015 m | 0.00000 (overlapping) |
 | Yaw band | each \|yaw\| in 0.040–0.192 rad | 0.0681, 0.0943, 0.1093 |
 | Per-instance variation | yaw spread ≥ 0.020 rad, plank spread ≥ 0.0008 m | 0.0262 rad, 0.00205 m |
+| Nail seat | 48 nails; bite 0.3–1.0 mm into the strap, head ≥ 1.0 mm proud | 48; bite 0.60 mm, proud 1.80 mm |
+| Edge treatment | manifold edges within 5° of a right angle: 0 | timber 0, iron 0 |
 
-Real-world size: each crate is 0.58 × 0.42 m at the timber and 0.585 × 0.425 m
-over the corner iron, 0.244 m tall including runners and lid. Three stacked
+Real-world size: each crate is 0.58 × 0.42 m at the timber and 0.588 × 0.428 m
+over the corner iron and its nail heads, 0.244 m tall including runners and lid. Three stacked
 come to 0.70 m — knee height, wider than tall.
 
 ### Why the footprint is measured in the crate's own frame
@@ -79,7 +81,7 @@ The stack AABB is the union of three yawed boxes, so a crate could drift to
 any size underneath it and the outer budget would not notice. Each crate's
 footprint is therefore measured after un-rotating by the yaw that crate was
 *measured* to have, not the yaw it was built with. All three land on
-0.5846 × 0.4246 m exactly, which is what makes the un-rotation trustworthy.
+0.5882 × 0.4282 m exactly, which is what makes the un-rotation trustworthy.
 
 ### Why parts are classified by principal axes
 
@@ -98,18 +100,48 @@ shifted a crate, and the seat budget then compared a crate against itself.
 The bands are clustered from the runner heights the mesh actually has, so
 they follow the geometry including when a falsifier moves it.
 
+### Why the corner iron is one shell
+
+Each strap used to be two overlapping boxes, one per leg of the L. Both
+boxes had a vertical edge on the strap's outer corner, and once the iron
+was chamfered each box laid a chamfer strip on that same line: a coplanar
+cross-shell pair at all twelve corners, which the z-fight budget caught.
+The strap is now a single L-section extrusion — each cap two convex quads
+meeting on the inner-corner diagonal, so no n-gon — with one outer corner.
+The iron bevel passes `material=METAL_IDX`; left to its default, bevel
+gave the chamfer faces slot 0 and the plates rendered and classified as
+timber.
+
+### Why nails are told from plates by the strap's size
+
+Nail and plate shells are both iron; the nail audit separates them by
+world-AABB extent. The threshold is `IRON_WRAP * 0.5`, derived from the
+strap. A fixed 10 mm threshold dropped 8 of 48 nails as soon as the heads
+grew to 10 mm, because a yawed head's world AABB is wider than the head.
+
+### Timber surface
+
+`paint_planks` writes two face attributes: `PlankTone`, a seeded tone per
+shell, and `GrainDir`, the shell's own long axis recovered from its
+vertices. The wood shader samples noise in object space with the
+component along `GrainDir` compressed, so the grain streaks run along
+each board whatever the crate's yaw, and scales the colour by the plank's
+tone. Neither attribute is a budget: a tone cannot be seen by an
+assertion, which is why the inspection sheet looked at it.
+
 ## Determinism
 
 Fixed seed 41; no unseeded randomness. Identical geometry across runs on one
 binary and across 4.5.11, 5.1.2 and 5.2.1 — every measured value above is
-byte-identical on the three **except** LOD2, where `DECIMATE COLLAPSE`
-produces 878 triangles on 5.2 and 934 on 4.5 and 5.1. That is why the LOD
-gate is a ratio band (0.10–0.35, measured 0.2005 and 0.2199) and not an exact
-count.
+byte-identical on the three. LOD2 used to differ — `DECIMATE COLLAPSE`
+produced 878 triangles on 5.2 and 934 on 4.5 and 5.1 on the earlier mesh —
+and on the current mesh lands on 1332 on all three. The LOD gate stays a
+ratio band (0.10–0.35) rather than an exact count, because that agreement
+is a property of this mesh, not of the modifier.
 
 ## Falsifiers
 
-Each breaks one pipeline stage so a **named** budget fails. All six were run
+Each breaks one pipeline stage so a **named** budget fails. All eight were run
 on 4.5.11, 5.1.2 and 5.2.1 and produced the same exit code on all three.
 
 | Flag | Breaks | Exit |
@@ -120,6 +152,8 @@ on 4.5.11, 5.1.2 and 5.2.1 and produced the same exit code on all three.
 | `--short-skids` | floats **one** of the three ground runners 12 mm; the other two still ground the AABB, so only the named-support budget sees it | 16 |
 | `--float-stack` | lifts the top crate 9 mm clear of the lid below, opening a 34 mm seat gap | 18 |
 | `--same-seed` | gives all three crates the same design seed; yaw spread and plank spread both go to 0 | 20 |
+| `--float-nails` | lifts every nail head 1.5 mm along its plate normal; bite goes to −0.90 mm, nail seat budget | 18 |
+| `--sharp-iron` | skips the iron chamfer pass; 216 right-angle iron edges, edge-treatment budget | 21 |
 
 ## Exit codes
 
@@ -145,9 +179,10 @@ against it. `1` is the FATAL wrapper — a crash, never a named check.
 | 14 | `--output` produced no file |
 | 15 | Mesh hygiene (`--stray-vert`) |
 | 16 | Grounded zmin, or a named ground runner floating (`--lift-z`, `--short-skids`) |
-| 18 | Crate-to-crate seat gap (`--float-stack`) |
+| 18 | Crate-to-crate seat gap (`--float-stack`), or a nail head off its strap seat band (`--float-nails`) |
 | 19 | Crate body footprint off declared size |
 | 20 | Per-instance variation collapsed (`--same-seed`) |
+| 21 | A manifold edge within 5° of a right angle: a chamfer pass skipped (`--sharp-iron`) |
 
 `17` is unused here: this piece has no diagonal member. `15`–`19` are
 reserved across showcase pieces for the hygiene family, so the numbering
@@ -156,7 +191,7 @@ skips rather than reuses.
 ## Run it
 
 ```bash
-# Budget check, no render. ~1.0 s on 4.5/5.1, ~1.2 s on 5.2.
+# Budget check, no render. ~1.4-1.7 s on 4.5 / 5.1 / 5.2.
 blender --background --python crate_stack.py --
 
 # Falsifier: the three crates become copies. Must exit 20.
@@ -175,11 +210,13 @@ Smoke runs the check-only path. It does not pass `--output` or any falsifier.
 
 | Value | 4.5.11 | 5.1.2 | 5.2.1 |
 | --- | --- | --- | --- |
-| Base triangles | 4380 | 4380 | 4380 |
-| LOD1 tris / ratio | 2190 / 0.5000 | 2190 / 0.5000 | 2190 / 0.5000 |
-| LOD2 tris / ratio | 934 / 0.2199 | 934 / 0.2199 | 878 / 0.2005 |
-| Outer AABB | 0.6582 × 0.5235 × 0.7040 | same | same |
-| Collider tris | 202 | 202 | 202 |
+| Base triangles | 6060 | 6060 | 6060 |
+| LOD1 tris / ratio | 3030 / 0.5000 | 3030 / 0.5000 | 3030 / 0.5000 |
+| LOD2 tris / ratio | 1332 / 0.2198 | 1332 / 0.2198 | 1332 / 0.2198 |
+| Outer AABB | 0.6583 × 0.5235 × 0.7040 | same | same |
+| Collider tris | 230 | 230 | 230 |
 | Yaws (rad) | 0.0943, −0.1093, 0.0681 | same | same |
 | Seat gap | 0.00000 | 0.00000 | 0.00000 |
-| Check wall-clock | ~0.99 s | ~1.01 s | ~1.20 s |
+| Nails / bite / proud | 48 / 0.60 mm / 1.80 mm | same | same |
+| Right-angle edges | 0 | 0 | 0 |
+| Check wall-clock | ~1.59 s | ~1.41 s | ~1.65 s |
diff --git a/showcase/crate-stack/crate_stack.py b/showcase/crate-stack/crate_stack.py
index 1e1c848f..eaa012b7 100644
--- a/showcase/crate-stack/crate_stack.py
+++ b/showcase/crate-stack/crate_stack.py
@@ -20,7 +20,8 @@
 budget: ``--skip-decimate`` the LOD-ratio band, ``--stray-vert`` mesh
 hygiene, ``--lift-z`` grounded zmin, ``--short-skids`` the named ground
 supports, ``--float-stack`` the crate-to-crate seat, ``--same-seed`` the
-per-instance variation budget.
+per-instance variation budget, ``--float-nails`` the nail seat,
+``--sharp-iron`` the edge-treatment budget.
 
 Fixed seed 41. DECIMATE COLLAPSE triangle counts are not byte-identical
 across Blender versions — the LOD gate is a ratio band, not an exact
@@ -70,6 +71,32 @@
 # The lid bites down onto the rails for the same reason: a lid resting
 # exactly on the rail top shares that plane and those corner vertices.
 LID_BITE = 0.004
+# Iron is chamfered like the timber, only finer: a 3.5 mm plate with the
+# timber's 1.8 mm bevel would have no flat left.
+IRON_BEVEL = 0.0008
+# Clout nails: two per plate, driven through the strap into the post. The
+# shank end sits a named bite below the plate face so each head is seated,
+# not parked on the surface; the head is a frustum so no visible edge of it
+# is a right angle.
+NAIL_R = 0.0050
+NAIL_R_TOP = 0.0036
+NAIL_H = 0.0024
+NAIL_BITE = 0.0006
+NAIL_SEGS = 6
+NAIL_ZS = (0.18, 0.82)
+NAIL_BITE_MIN = 0.0003
+NAIL_BITE_MAX = 0.0010
+NAIL_PROUD_MIN = 0.0010
+# Nail versus plate is told apart by world-AABB extent. Derived from the
+# strap, not the nail: a yawed 10 mm head has an AABB wider than 10 mm, and
+# a fixed 10 mm threshold dropped 8 of 48 nails the moment the heads grew.
+NAIL_EXTENT_MAX = IRON_WRAP * 0.5
+FLOAT_NAIL_LIFT = 0.0015
+# Edge treatment: no manifold edge on the finished mesh is a right angle.
+# Every box edge is chamfered, so a 90-degree edge means a bevel pass was
+# skipped.
+RIGHT_ANGLE_TOL = math.radians(5.0)
+PLANK_TONE_JITTER = 0.30
 BODY_H = 0.205
 N_SIDE = 3
 N_END = 2
@@ -90,18 +117,24 @@
 YAW_SPREAD_MIN = 0.020
 WIDTH_SPREAD_MIN = 0.0008
 
+# Four corners, two plates per corner, one nail per plate per station.
+N_NAILS = N_CRATES * 4 * 2 * len(NAIL_ZS)
+
 CRATE_H = SKID_H + BODY_H + SLAT_T - LID_BITE
 STACK_H = N_CRATES * CRATE_H - (N_CRATES - 1) * STACK_BITE
 
 BBOX_TOL = 0.020
 OUTER_SIZE = (0.658, 0.524, 0.704)
-# The crate body over its corner iron, measured in the crate's own frame.
-BODY_X = CRATE_X + 2.0 * (IRON_T - IRON_BITE)
-BODY_Y = CRATE_Y + 2.0 * (IRON_T - IRON_BITE)
+# The crate body over its corner iron and nail heads, in the crate's own frame.
+# The strap stands IRON_T - IRON_BITE proud of the post, and each nail
+# head a further NAIL_H - NAIL_BITE proud of the strap.
+BODY_PROUD = IRON_T - IRON_BITE + NAIL_H - NAIL_BITE
+BODY_X = CRATE_X + 2.0 * BODY_PROUD
+BODY_Y = CRATE_Y + 2.0 * BODY_PROUD
 CRATE_TOL = 0.015
 
-BASE_TRIS_MIN = 3200
-BASE_TRIS_MAX = 7200
+BASE_TRIS_MIN = 5200
+BASE_TRIS_MAX = 7000
 LOD1_RATIO_MIN = 0.32
 LOD1_RATIO_MAX = 0.62
 LOD2_RATIO_MIN = 0.10
@@ -114,8 +147,8 @@
 COLLIDER_TRIS_MAX = 260
 BAKE_RES = 256
 CAGE_EXTRUSION = 0.08
-METAL_FACES_MIN = 120
-WOOD_FACES_MIN = 600
+METAL_FACES_MIN = 900
+WOOD_FACES_MIN = 1800
 ZMIN_EPS = 1e-4
 DOUBLES_EPS = 1e-5
 AREA_EPS = 1e-10
@@ -232,7 +265,9 @@ def _span_layout(count, span, rng, gap=0.009):
     return centres, widths
 
 
-def build_crate(bm, base_z, yaw, rng, offset=(0.0, 0.0), short_skids=False):
+def build_crate(
+    bm, base_z, yaw, rng, offset=(0.0, 0.0), short_skids=False, float_nails=False
+):
     """One crate, placed with its skid underside at *base_z* and yawed.
 
     Called once per stack level. Everything that differs between levels
@@ -362,23 +397,88 @@ def build_crate(bm, base_z, yaw, rng, offset=(0.0, 0.0), short_skids=False):
     # Outer face of each plate, after biting into the post.
     px = CRATE_X / 2.0 + IRON_T - IRON_BITE
     py = CRATE_Y / 2.0 + IRON_T - IRON_BITE
+    plates = []
     for sxn in (-1.0, 1.0):
         for syn in (-1.0, 1.0):
-            add_box(
-                bm,
-                (sxn * (px - IRON_T / 2.0), syn * (py - IRON_WRAP / 2.0), zc),
-                (IRON_T, IRON_WRAP, strap_h),
-                METAL_IDX,
-                xform,
-            )
-            add_box(
-                bm,
-                (sxn * (px - IRON_WRAP / 2.0), syn * (py - IRON_T / 2.0), zc),
-                (IRON_WRAP, IRON_T, strap_h - 2.0 * IRON_T),
-                METAL_IDX,
-                xform,
-            )
-    return wood, side_w
+            plates.extend(add_strap(bm, sxn, syn, px, py, strap_z0, strap_h, xform))
+    # Nails are placed from the plate's own outer face and normal, so they
+    # follow the strap if its thickness, bite or wrap ever changes.
+    nail_stations = []
+    for sxn in (-1.0, 1.0):
+        for syn in (-1.0, 1.0):
+            for fz in NAIL_ZS:
+                z = strap_z0 + strap_h * fz
+                nail_stations.append(
+                    (Vector((sxn * px, syn * (py - IRON_WRAP * 0.5), z)),
+                     Vector((sxn, 0.0, 0.0)))
+                )
+                nail_stations.append(
+                    (Vector((sxn * (px - IRON_WRAP * 0.5), syn * py, z)),
+                     Vector((0.0, syn, 0.0)))
+                )
+    for face_pt, nrm in nail_stations:
+        add_nail(bm, face_pt, nrm, xform, lift=FLOAT_NAIL_LIFT if float_nails else 0.0)
+    return wood, side_w, plates
+
+
+def add_strap(bm, sxn, syn, px, py, z0, h, xform):
+    """One L-section corner strap, a single closed shell.
+
+    Two overlapping boxes shared their outer corner edge, so once the iron
+    was chamfered both boxes put a strip on the same line: a coplanar pair
+    at every corner. An extruded L has one outer corner. Each cap is two
+    convex quads meeting on the inner-corner diagonal, so there is no n-gon.
+    """
+    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 = []
+    for z in (z0, z0 + h):
+        rings.append(
+            [bm.verts.new(xform @ Vector((sxn * x, syn * y, z))) for x, y in outline]
+        )
+    lo, hi = rings
+    faces = []
+    # Bottom cap wound opposite the top so the shell is consistently
+    # oriented; recalc_face_normals later points it outward.
+    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))
+    n = len(outline)
+    for i in range(n):
+        j = (i + 1) % n
+        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, xform, lift=0.0):
+    """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()
+    seat = Matrix.Translation(face_pt + nrm * lift) @ orient @ Matrix.Translation(
+        (0.0, 0.0, NAIL_H / 2.0 - NAIL_BITE)
+    )
+    verts = geo["verts"]
+    for v in verts:
+        v.co = xform @ (seat @ v.co)
+    for f in {f for v in verts for f in v.link_faces}:
+        f.material_index = METAL_IDX
 
 
 def build_stack_mesh(
@@ -386,9 +486,12 @@ def build_stack_mesh(
     same_seed=False,
     short_skids=False,
     float_stack=False,
+    float_nails=False,
+    sharp_iron=False,
 ):
     bm = bmesh.new()
     wood_verts = []
+    plate_verts = []
     try:
         base_z = 0.0
         for i in range(N_CRATES):
@@ -407,17 +510,41 @@ def build_stack_mesh(
                 0.0 if i == 0 else place.uniform(-OFFSET_MAX, OFFSET_MAX),
             )
             lift = FLOAT_LIFT if (float_stack and i == N_CRATES - 1) else 0.0
-            verts, _widths = build_crate(
+            verts, _widths, plates = build_crate(
                 bm,
                 base_z + lift,
                 yaw,
                 rng,
                 offset=offset,
                 short_skids=short_skids and i == 0,
+                float_nails=float_nails,
             )
             wood_verts.extend(verts)
+            plate_verts.extend(plates)
             base_z += CRATE_H - STACK_BITE
 
+        # Iron first, at its own finer offset: the plates are only 3.5 mm
+        # thick. The nails are frustums and need no bevel.
+        # The flat diagonal inside each L cap is not an edge anyone sees,
+        # and chamfering it would crease a flat face.
+        if plate_verts and not sharp_iron:
+            edges = [
+                e for e in {e for v in plate_verts for e in v.link_edges}
+                if len(e.link_faces) == 2 and e.calc_face_angle(0.0) > 1e-3
+            ]
+            # material= pins the chamfer faces to iron; left to default,
+            # bevel handed them slot 0 and the plates rendered as timber.
+            bmesh.ops.bevel(
+                bm,
+                geom=edges,
+                offset=IRON_BEVEL,
+                segments=1,
+                profile=0.5,
+                affect="EDGES",
+                clamp_overlap=True,
+                material=METAL_IDX,
+            )
+
         if wood_verts:
             edges = list({e for v in wood_verts for e in v.link_edges if v.is_valid})
             if edges:
@@ -445,11 +572,40 @@ def build_stack_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 paint_planks(me):
+    """Per-plank tone and grain direction, as face attributes.
+
+    Every plank came out of one material, so every plank was the same
+    board. Each shell gets a seeded tone and the direction it runs in —
+    its long axis, recovered from its own vertices — which the wood shader
+    uses to stretch its grain along the board rather than along a world
+    axis that is 6 degrees off on a yawed crate.
+    """
+    tone = [0.5] * len(me.polygons)
+    grain = [(1.0, 0.0, 0.0)] * len(me.polygons)
+    vf = vert_faces(me)
+    rng = random.Random(STACK_SEED * 13)
+    for g in shells(me):
+        pts = [me.vertices[i].co for i in g]
+        e1, _e2, theta = xy_principal(pts)
+        dz = max(p.z for p in pts) - min(p.z for p in pts)
+        d = (0.0, 0.0, 1.0) if dz > e1 else (math.cos(theta), math.sin(theta), 0.0)
+        t = 0.5 + rng.uniform(-PLANK_TONE_JITTER, PLANK_TONE_JITTER)
+        for fi in {fi for i in g for fi in vf[i]}:
+            tone[fi] = t
+            grain[fi] = d
+    a = me.attributes.new("PlankTone", "FLOAT", "FACE")
+    a.data.foreach_set("value", tone)
+    b = me.attributes.new("GrainDir", "FLOAT_VECTOR", "FACE")
+    b.data.foreach_set("vector", [c for v in grain for c in v])
+
+
 def principled(name, color, metallic, roughness, noise_scale=0.0, wear=None):
     mat = bpy.data.materials.new(name)
     mat.use_nodes = True
@@ -480,6 +636,92 @@ def principled(name, color, metallic, roughness, noise_scale=0.0, wear=None):
     return mat
 
 
+def _sock(sockets, identifier):
+    """A Mix-node socket by identifier; its A/B/Result names repeat per type."""
+    return next(s for s in sockets if s.identifier == identifier)
+
+
+def wood_material(name):
+    """Timber whose grain runs along each board and whose tone varies by plank.
+
+    Reads the ``PlankTone`` and ``GrainDir`` face attributes that
+    ``paint_planks`` writes. The grain is noise sampled in object space with
+    the component along the board compressed, so its streaks are long in
+    the direction the plank runs whatever the crate's yaw.
+    """
+    mat = bpy.data.materials.new(name)
+    mat.use_nodes = True
+    nt = mat.node_tree
+    bsdf = nt.nodes["Principled BSDF"]
+    bsdf.inputs["Metallic"].default_value = 0.0
+    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])
+    # Plank tone also offsets the grain sample, so neighbouring boards do
+    # not show one continuous figure across the gap between them.
+    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 = 34.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.105, 0.045, 0.016, 1.0)
+    ramp.color_ramp.elements[1].position = 0.72
+    ramp.color_ramp.elements[1].color = (0.34, 0.16, 0.060, 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.2
+    gain.inputs[2].default_value = 0.40
+    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 stack_materials():
+    """(wood, iron) — shared by the check path, the render and inspection."""
+    wood = wood_material("StackWood")
+    metal = principled(
+        "StackMetal", (0.17, 0.165, 0.155, 1.0), 0.80, 0.46,
+        noise_scale=18.0, wear=(0.20, 0.085, 0.032, 1.0),
+    )
+    return wood, metal
+
+
 def assign_slots(obj, wood, metal):
     mats = obj.data.materials
     for i, mat in enumerate((wood, metal)):
@@ -947,6 +1189,78 @@ def crate_size_audit(me, yaws, bases):
     return out
 
 
+def right_angle_edges(me):
+    """Manifold edges whose two faces meet at 90 degrees, iron and timber.
+
+    Every box in the piece is chamfered, and a one-segment chamfer turns a
+    90-degree edge into two 45-degree ones. An edge still at 90 is one a
+    bevel pass skipped: the razor edge that renders as a hard black line.
+    """
+    counts = {WOOD_IDX: 0, METAL_IDX: 0}
+    bm = bmesh.new()
+    try:
+        bm.from_mesh(me)
+        for e in bm.edges:
+            if len(e.link_faces) != 2:
+                continue
+            if abs(e.calc_face_angle(0.0) - math.pi / 2.0) <= RIGHT_ANGLE_TOL:
+                idx = e.link_faces[0].material_index
+                counts[idx] = counts.get(idx, 0) + 1
+    finally:
+        bm.free()
+    return counts
+
+
+def nail_audit(me):
+    """Seat of every nail head in its strap, measured against the plate.
+
+    Nails are the small iron shells; plates are the rest. Each nail vertex
+    gets a signed distance to the plate surface (negative inside). The
+    deepest is the bite, which must sit in a band — not parked on the plate
+    and not sunk through it — and the highest is how proud the head
+    stands, which must be enough to catch light.
+    """
+    vf = vert_faces(me)
+    nails, plates = [], []
+    for g in shells(me):
+        if mat_of(me, g, vf) != METAL_IDX:
+            continue
+        lo_hi = shell_aabb(me, g)
+        ext = max(lo_hi[3] - lo_hi[0], lo_hi[4] - lo_hi[1], lo_hi[5] - lo_hi[2])
+        (nails if ext < NAIL_EXTENT_MAX else plates).append(g)
+    if not nails or not plates:
+        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 = set()
+        for g in plates:
+            keep.update(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)
+            if loc is None:
+                signed.append(99.0)
+                continue
+            signed.append((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 add_stray_vert(me):
     bm = bmesh.new()
     try:
@@ -1053,24 +1367,21 @@ def check(
     short_skids=False,
     float_stack=False,
     same_seed=False,
+    float_nails=False,
+    sharp_iron=False,
 ):
     bpy.ops.wm.read_factory_settings(use_empty=True)
     flags = dict(
         same_seed=same_seed,
         short_skids=short_skids,
         float_stack=float_stack,
+        float_nails=float_nails,
+        sharp_iron=sharp_iron,
     )
     nothing = (None,) * 5
     low = build_stack_mesh("StackLow", **flags)
     high = build_stack_mesh("StackHigh", **flags)
-    wood = principled(
-        "StackWood", (0.40, 0.18, 0.065, 1.0), 0.0, 0.55,
-        noise_scale=9.0, wear=(0.20, 0.085, 0.030, 1.0),
-    )
-    metal = principled(
-        "StackMetal", (0.20, 0.19, 0.180, 1.0), 0.88, 0.33,
-        noise_scale=6.0, wear=(0.10, 0.095, 0.088, 1.0),
-    )
+    wood, metal = stack_materials()
     assign_slots(low, wood, metal)
     assign_slots(high, wood, metal)
     if stray_vert:
@@ -1120,11 +1431,17 @@ 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)
     st = stack_audit(low.data)
     crates = crate_size_audit(low.data, st['yaws'], st['bases'])
+    nails = nail_audit(low.data)
+    right = right_angle_edges(low.data)
 
     print(f"blender={tuple(bpy.app.version)} skip_decimate={skip_decimate}")
     print(f"measured mat_index_counts={idx_counts}")
@@ -1164,6 +1481,12 @@ def check(
         "measured crate_footprints="
         f"{[(round(c[0], 4), round(c[1], 4)) for c in crates]}"
     )
+    print(
+        f"measured nails n={nails['n']} bite=[{nails['bite_min']:.5f}, "
+        f"{nails['bite_max']:.5f}] proud_min={nails['proud_min']:.5f} "
+        f"right_angle_edges wood={right.get(WOOD_IDX, 0)} "
+        f"iron={right.get(METAL_IDX, 0)}"
+    )
 
     if not (BASE_TRIS_MIN <= base_tris <= BASE_TRIS_MAX):
         return (fail(
@@ -1237,6 +1560,19 @@ def check(
             f"stack seat gap {st['seat']:.5f} > {STACK_SEAT_MAX} over "
             f"{st['seats']} seats (--float-stack is the designed fail)", 18
         ),) + nothing
+    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
+        ),) + nothing
     for i, (cx, cy) in enumerate(crates):
         if abs(cx - BODY_X) > CRATE_TOL or abs(cy - BODY_Y) > CRATE_TOL:
             return (fail(
@@ -1254,6 +1590,12 @@ def check(
             f"(min {WIDTH_SPREAD_MIN}) — the three crates are copies, not "
             "instances (--same-seed is the designed fail)", 20
         ),) + nothing
+    if sum(right.values()):
+        return (fail(
+            f"right-angle edges wood={right.get(WOOD_IDX, 0)} "
+            f"iron={right.get(METAL_IDX, 0)}: a chamfer pass was skipped "
+            "(--sharp-iron is the designed fail)", 21
+        ),) + nothing
     return 0, low, high, wood, tex, collider
 
 
@@ -1375,6 +1717,8 @@ def main():
     p.add_argument("--short-skids", action="store_true")
     p.add_argument("--float-stack", action="store_true")
     p.add_argument("--same-seed", action="store_true")
+    p.add_argument("--float-nails", action="store_true")
+    p.add_argument("--sharp-iron", action="store_true")
     args = p.parse_args(argv)
 
     code, low, _high, wood, tex, _col = check(
@@ -1384,6 +1728,8 @@ def main():
         short_skids=args.short_skids,
         float_stack=args.float_stack,
         same_seed=args.same_seed,
+        float_nails=args.float_nails,
+        sharp_iron=args.sharp_iron,
     )
     if code:
         return code
diff --git a/showcase/crate-stack/preview.webp b/showcase/crate-stack/preview.webp
index 178123a4..0eca1db0 100644
Binary files a/showcase/crate-stack/preview.webp and b/showcase/crate-stack/preview.webp differ
diff --git a/showcase/gallery.json b/showcase/gallery.json
index d7693b84..35931843 100644
--- a/showcase/gallery.json
+++ b/showcase/gallery.json
@@ -352,7 +352,7 @@
       "name": "crate-stack",
       "dir": "showcase/crate-stack",
       "teaches": "A stack of three procedural shipping crates built by one generator called three times with a per-instance seed, carried through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.",
-      "alt": "Three wooden shipping crates stacked, each turned slightly differently.",
+      "alt": "Three grained wooden shipping crates stacked, each turned slightly differently, with nailed iron corner straps.",
       "witnessesFix": "Recomputed: 4380 tris, two materials with 216 iron and 2436 timber faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.658×0.524×0.704 m, zmin 0, hygiene 0 including zero coplanar disjoint pairs, three ground runners at z=0, both crate-to-crate seats overlapping, each crate's own footprint 0.585×0.425 m measured in its own frame, yaw spread 0.026 rad and plank spread 2.05 mm across instances, LOD ratios in band, convex collider 202 tris, non-empty glTF. --float-stack exits 18 on the seat; --same-seed exits 20 on per-instance variation.",
       "hero": "docs/gallery/assets/crate-stack-hero.webp",
       "preview": "showcase/crate-stack/preview.webp",