diff --git a/docs/gallery/assets/gn-sdf-remesh-hero.webp b/docs/gallery/assets/gn-sdf-remesh-hero.webp
index 056fbded..8b764927 100644
Binary files a/docs/gallery/assets/gn-sdf-remesh-hero.webp and b/docs/gallery/assets/gn-sdf-remesh-hero.webp differ
diff --git a/docs/gallery/assets/water-trough-hero.webp b/docs/gallery/assets/water-trough-hero.webp
index 39c58dc8..a5712176 100644
Binary files a/docs/gallery/assets/water-trough-hero.webp and b/docs/gallery/assets/water-trough-hero.webp differ
diff --git a/docs/gallery/contact-sheets/gn-sdf-remesh-contact-sheet.webp b/docs/gallery/contact-sheets/gn-sdf-remesh-contact-sheet.webp
index 5358da67..4d0f98e8 100644
Binary files a/docs/gallery/contact-sheets/gn-sdf-remesh-contact-sheet.webp and b/docs/gallery/contact-sheets/gn-sdf-remesh-contact-sheet.webp differ
diff --git a/docs/gallery/contact-sheets/water-trough-contact-sheet.webp b/docs/gallery/contact-sheets/water-trough-contact-sheet.webp
index 783523f5..84e27e3c 100644
Binary files a/docs/gallery/contact-sheets/water-trough-contact-sheet.webp and b/docs/gallery/contact-sheets/water-trough-contact-sheet.webp differ
diff --git a/docs/gallery/gn-sdf-remesh/index.html b/docs/gallery/gn-sdf-remesh/index.html
index 86d92c8c..830f8416 100644
--- a/docs/gallery/gn-sdf-remesh/index.html
+++ b/docs/gallery/gn-sdf-remesh/index.html
@@ -16,13 +16,13 @@
   <meta property="og:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/gn-sdf-remesh-hero.webp" />
   <meta property="og:image:width" content="1280" />
   <meta property="og:image:height" content="720" />
-  <meta property="og:image:alt" content="A glossy red torus with visibly blocky voxel faceting from the SDF remesh." />
+  <meta property="og:image:alt" content="Two red tori side by side under pale edge cages: the source with even ring topology, and its SDF remesh covered in a dense irregular voxel grid." />
   <meta property="og:site_name" content="Blender Developer Tools" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="gn-sdf-remesh — Examples — Blender Developer Tools" />
   <meta name="twitter:description" content="A Geometry Nodes SDF remesh (MeshToSDFGrid → GridToMesh at the SDF zero-level), with a Set Material node carrying the material through the remesh." />
   <meta name="twitter:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/gn-sdf-remesh-hero.webp" />
-  <meta name="twitter:image:alt" content="A glossy red torus with visibly blocky voxel faceting from the SDF remesh." />
+  <meta name="twitter:image:alt" content="Two red tori side by side under pale edge cages: the source with even ring topology, and its SDF remesh covered in a dense irregular voxel grid." />
   <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>gn-sdf-remesh</h1>
     <p>A Geometry Nodes SDF remesh (MeshToSDFGrid → GridToMesh at the SDF zero-level), with a Set Material node carrying the material through the remesh.</p>
   </header>
   <main id="main">
-    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: A glossy red torus with visibly blocky voxel faceting from the SDF remesh.">
-      <img src="../assets/gn-sdf-remesh-hero.webp" alt="A glossy red torus with visibly blocky voxel faceting from the SDF remesh." width="1280" height="720" />
+    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: Two red tori side by side under pale edge cages: the source with even ring topology, and its SDF remesh covered in a dense irregular voxel grid.">
+      <img src="../assets/gn-sdf-remesh-hero.webp" alt="Two red tori side by side under pale edge cages: the source with even ring topology, and its SDF remesh covered in a dense irregular voxel grid." 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> An SDF grid is meshed with Grid to Mesh, not Volume to Mesh; GN geometry needs Set Material or it renders untextured.</div>
@@ -377,10 +377,56 @@ <h2>Source</h2>
     wall.rotation_euler = (<span class="n">1.5708</span>, <span class="n">0</span>, <span class="n">0</span>); bpy.context.collection.objects.link(wall)
     w = bpy.data.worlds.new(<span class="s">&quot;W&quot;</span>); w.use_nodes = <span class="k">True</span>
     w.node_tree.nodes[<span class="s">&quot;Background&quot;</span>].inputs[<span class="n">0</span>].default_value = (<span class="n">0.02</span>, <span class="n">0.021</span>, <span class="n">0.025</span>, <span class="n">1</span>); sc.world = w
-    aim = bpy.data.objects.new(<span class="s">&quot;Aim&quot;</span>, <span class="k">None</span>); aim.location = (<span class="n">0</span>, <span class="n">0</span>, <span class="n">0.5</span>); bpy.context.collection.objects.link(aim)
-    <span class="c"># off-axis and low: the remesh facets are the API evidence, and they only</span>
-    <span class="c"># read when a raking key skims them from the side</span>
-    cam = bpy.data.objects.new(<span class="s">&quot;cam&quot;</span>, bpy.data.cameras.new(<span class="s">&quot;cam&quot;</span>)); cam.location = (<span class="n">2.6</span>, -<span class="n">5.2</span>, <span class="n">1.5</span>)
+    <span class="c"># Input beside output. Alone, the remeshed torus read as a glossy inner</span>
+    <span class="c"># tube with blotchy highlights: nothing said &quot;remeshed&quot;. The source torus</span>
+    <span class="c"># (a modifier-free copy of the same datablock) on the left and the SDF</span>
+    <span class="c"># result on the right, each under a cage of its own edges, show the</span>
+    <span class="c"># thing the check measures: UV-ring topology in, voxel-grid topology</span>
+    <span class="c"># out. Render-path scaffolding only; the check ran before this.</span>
+    obj.location.x = <span class="n">1.85</span>
+    src = bpy.data.objects.new(<span class="s">&quot;SourceTorus&quot;</span>, obj.data.copy())
+    src.location = (-<span class="n">1.85</span>, obj.location.y, obj.location.z)
+    bpy.context.collection.objects.link(src)
+    <span class="c"># build() centres the torus at z=0.55 with a 0.5 minor radius, so both</span>
+    <span class="c"># hovered 5 cm over the floor. Ground each on its own measured bottom:</span>
+    <span class="c"># the SDF surface is not exactly the source surface.</span>
+    dg0 = bpy.context.evaluated_depsgraph_get()
+    em = obj.evaluated_get(dg0).to_mesh()
+    obj.location.z -= obj.location.z + min(v.co.z <span class="k">for</span> v <span class="k">in</span> em.vertices)
+    obj.evaluated_get(dg0).to_mesh_clear()
+    src.location.z = -min(v.co.z <span class="k">for</span> v <span class="k">in</span> src.data.vertices)
+    cage_mat = bpy.data.materials.new(<span class="s">&quot;Cage&quot;</span>); cage_mat.use_nodes = <span class="k">True</span>
+    cb = cage_mat.node_tree.nodes.get(<span class="s">&#x27;Principled BSDF&#x27;</span>)
+    cb.inputs[<span class="s">&#x27;Base Color&#x27;</span>].default_value = (<span class="n">0.92</span>, <span class="n">0.82</span>, <span class="n">0.62</span>, <span class="n">1</span>)
+    cb.inputs[<span class="s">&#x27;Roughness&#x27;</span>].default_value = <span class="n">0.4</span>
+    cages = []
+    dg = bpy.context.evaluated_depsgraph_get()
+    <span class="k">for</span> host, remeshed <span class="k">in</span> ((src, <span class="k">False</span>), (obj, <span class="k">True</span>)):
+        <span class="c"># The remeshed cage is the evaluated result frozen into a plain mesh:</span>
+        <span class="c"># a live copy of the tree would re-apply its Set Material and paint</span>
+        <span class="c"># the cage crimson.</span>
+        data = (bpy.data.meshes.new_from_object(obj.evaluated_get(dg))
+                <span class="k">if</span> remeshed <span class="k">else</span> obj.data.copy())
+        cage = bpy.data.objects.new(host.name + <span class="s">&quot;Cage&quot;</span>, data)
+        cage.data.materials.clear(); cage.data.materials.append(cage_mat)
+        <span class="k">for</span> poly <span class="k">in</span> cage.data.polygons:
+            poly.material_index = <span class="n">0</span>
+        cage.location = host.location
+        wire = cage.modifiers.new(<span class="s">&quot;cage&quot;</span>, <span class="s">&#x27;WIREFRAME&#x27;</span>)
+        wire.thickness = <span class="n">0.012</span>; wire.offset = <span class="n">1.0</span>; wire.use_even_offset = <span class="k">True</span>
+        wire.material_offset = <span class="n">0</span>
+        bpy.context.collection.objects.link(cage)
+        cages.append(cage)
+    <span class="c"># Softer than 0.16: at that gloss every voxel facet threw its own hard</span>
+    <span class="c"># glint and the highlight broke into blocks that read as artifacts.</span>
+    <span class="k">for</span> m <span class="k">in</span> obj.data.materials:
+        <span class="k">if</span> m <span class="k">is</span> <span class="k">not</span> <span class="k">None</span> <span class="k">and</span> m.node_tree <span class="k">is</span> <span class="k">not</span> <span class="k">None</span>:
+            bsdf = m.node_tree.nodes.get(<span class="s">&#x27;Principled BSDF&#x27;</span>)
+            <span class="k">if</span> bsdf <span class="k">is</span> <span class="k">not</span> <span class="k">None</span>:
+                bsdf.inputs[<span class="s">&#x27;Roughness&#x27;</span>].default_value = <span class="n">0.32</span>
+    aim = bpy.data.objects.new(<span class="s">&quot;Aim&quot;</span>, <span class="k">None</span>); aim.location = (<span class="n">0</span>, <span class="n">0</span>, <span class="n">0.45</span>); bpy.context.collection.objects.link(aim)
+    <span class="c"># Raised so both donut holes read, and pulled back to hold the pair.</span>
+    cam = bpy.data.objects.new(<span class="s">&quot;cam&quot;</span>, bpy.data.cameras.new(<span class="s">&quot;cam&quot;</span>)); cam.location = (<span class="n">1.5</span>, -<span class="n">10.8</span>, <span class="n">5.5</span>)
     bpy.context.collection.objects.link(cam); sc.camera = cam
     c = cam.constraints.new(<span class="s">&#x27;TRACK_TO&#x27;</span>); c.target = aim; c.track_axis = <span class="s">&#x27;TRACK_NEGATIVE_Z&#x27;</span>; c.up_axis = <span class="s">&#x27;UP_Y&#x27;</span>
     <span class="c"># low raking warm key so every facet catches a distinct glint, faint cool</span>
@@ -466,7 +512,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/gn-sdf-remesh-hero.webp" alt="A glossy red torus with visibly blocky voxel faceting from the SDF remesh." />
+    <img src="../assets/gn-sdf-remesh-hero.webp" alt="Two red tori side by side under pale edge cages: the source with even ring topology, and its SDF remesh covered in a dense irregular voxel grid." />
   </dialog>
   <footer>
     <div class="statusbar">
diff --git a/docs/gallery/index.html b/docs/gallery/index.html
index fcefb4b9..b63d0705 100644
--- a/docs/gallery/index.html
+++ b/docs/gallery/index.html
@@ -365,7 +365,7 @@ <h2><a href="turntable/">turntable</a></h2>
       </article>
       <article class="card" data-tags="geometry-nodes materials">
         <a class="card-media" href="gn-sdf-remesh/" tabindex="-1" aria-hidden="true">
-          <img src="assets/gn-sdf-remesh-hero.webp" alt="A glossy red torus with visibly blocky voxel faceting from the SDF remesh." loading="lazy" decoding="async" />
+          <img src="assets/gn-sdf-remesh-hero.webp" alt="Two red tori side by side under pale edge cages: the source with even ring topology, and its SDF remesh covered in a dense irregular voxel grid." loading="lazy" decoding="async" />
         </a>
         <div class="card-body">
           <h2><a href="gn-sdf-remesh/">gn-sdf-remesh</a></h2>
@@ -1058,7 +1058,7 @@ <h2><a href="anvil/">anvil</a></h2>
       </article>
       <article class="card" data-tags="mesh export showcase">
         <a class="card-media" href="water-trough/" tabindex="-1" aria-hidden="true">
-          <img src="assets/water-trough-hero.webp" alt="A curved wooden water trough on crossed trestle legs, filled with dark green water." loading="lazy" decoding="async" />
+          <img src="assets/water-trough-hero.webp" alt="A staved wooden water trough with solid half-round end boards on crossed trestle legs, half full of dark water." loading="lazy" decoding="async" />
         </a>
         <div class="card-body">
           <h2><a href="water-trough/">water-trough</a></h2>
diff --git a/docs/gallery/water-trough/index.html b/docs/gallery/water-trough/index.html
index cc744d90..ebf4e6a5 100644
--- a/docs/gallery/water-trough/index.html
+++ b/docs/gallery/water-trough/index.html
@@ -16,13 +16,13 @@
   <meta property="og:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/water-trough-hero.webp" />
   <meta property="og:image:width" content="1280" />
   <meta property="og:image:height" content="720" />
-  <meta property="og:image:alt" content="A curved wooden water trough on crossed trestle legs, filled with dark green water." />
+  <meta property="og:image:alt" content="A staved wooden water trough with solid half-round end boards on crossed trestle legs, half full of dark water." />
   <meta property="og:site_name" content="Blender Developer Tools" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="water-trough — Showcase — Blender Developer Tools" />
   <meta name="twitter:description" content="A procedural watertight water trough 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/water-trough-hero.webp" />
-  <meta name="twitter:image:alt" content="A curved wooden water trough on crossed trestle legs, filled with dark green water." />
+  <meta name="twitter:image:alt" content="A staved wooden water trough with solid half-round end boards on crossed trestle legs, half full of dark water." />
   <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>water-trough</h1>
     <p>A procedural watertight water trough through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.</p>
   </header>
   <main id="main">
-    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: A curved wooden water trough on crossed trestle legs, filled with dark green water.">
-      <img src="../assets/water-trough-hero.webp" alt="A curved wooden water trough on crossed trestle legs, filled with dark green water." width="1280" height="720" />
+    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: A staved wooden water trough with solid half-round end boards on crossed trestle legs, half full of dark water.">
+      <img src="../assets/water-trough-hero.webp" alt="A staved wooden water trough with solid half-round end boards on crossed trestle legs, half full of dark water." 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: 3700 tris, three materials with 1674 wood, 156 metal and 29 water faces, UVs in 0..1 with zero AABB overlap, outer AABB 1.093×0.552×0.504 m, zmin 0, four shoes planted, U end-cap rim span 5 mm, strap BVH gap 0, water-hull gap 2.6 mm, hull 1.045×0.466 m, LOD ratios in band, convex collider 64 tris, non-empty glTF. --skip-decimate exits 9; --stray-vert 15; --lift-z/--short-legs 16; --box-ends 17; --float-strap 18; --narrow-hull 19.</div>
@@ -278,26 +278,31 @@ <h1>water-trough</h1>
       <button class="copy-btn" id="copyRun" type="button">Copy</button>
     </div>
     <section class="detail-section md">
-<p>A showcase piece, not an example. Procedural staved water trough on a timber stand (watertight U-hull, U end-caps, contained water, iron straps, trestle legs) then the shipped pipeline: unique-cell UVs, Cycles high-to-low normal bake, LOD chain, convex collider, Unity glTF export.</p>
-<p>The hull, ends, straps and water all sample the same YZ arc. End caps are U-boards the staves tenon into, not a bounding-box slab around the U. Straps sit at <code>STRAP_X</code>, offset from <code>LEG_X</code>, so the trestle does not punch through the iron. Stretchers span the inner faces of the legs. <code>--round-band</code> is not used; <code>--float-strap</code> is the seat falsifier.</p>
+<p>A showcase piece, not an example. Procedural staved water trough on a timber stand (watertight U-hull, solid end boards, contained water, iron straps, trestle legs) then the shipped pipeline: unique-cell UVs, Cycles high-to-low normal bake, LOD chain, convex collider, Unity glTF export.</p>
+<p>The hull, ends, straps and water all sample the same YZ arc. Each end is a solid board whose bottom follows the hull&#x27;s outer arc and whose top is level, and the staves tenon into it. It is neither a bounding-box slab around the U (<code>--box-ends</code>) nor an open U-band (<code>--open-ends</code>). Straps sit at <code>STRAP_X</code>, offset from <code>LEG_X</code>, so the trestle does not punch through the iron. Stretchers span the inner faces of the legs. <code>--round-band</code> is not used; <code>--float-strap</code> is the seat falsifier.</p>
 <p>It asserts <strong>budget conformance</strong> of the generated result. It does not witness an API contract. &quot;It rendered without error&quot; is not a check.</p>
 <p><strong>Composes</strong> skills <code>mesh-editing-and-bmesh</code>, <code>bake-high-to-low</code>, <code>depsgraph-and-evaluated-data</code>, <code>engine-export-presets</code>, and snippets <code>bake_normal_high_to_low.py</code>, <code>setup_bake_target_image.py</code>, <code>lod_chain.py</code> / <code>decimate_to_budget.py</code>, <code>convex_hull_collider.py</code>, <code>export_preset_unity.py</code> (helpers copied, not imported as a package). Hygiene combinatorics match <code>examples/mesh-hygiene-audit</code> (copied, not imported).</p>
-<p>Intended size: 1.08 m tray length, 0.44 m across the U, 0.50 m overall height; outer AABB 1.093 × 0.552 × 0.504 m.</p>
+<p>Intended size: 1.08 m tray length, 0.44 m across the U, 0.50 m overall height; outer AABB 1.093 × 0.552 × 0.5055 m.</p>
 <h2>Budgets</h2>
 <p>Declared as named constants; every gate <strong>recomputes</strong> from the mesh, materials, UVs, evaluated LOD, collider, or export file.</p>
-<div class="table-wrap"><table><thead><tr><th scope="col">Axis</th><th scope="col">Declared</th><th scope="col">Measured (4.5.11 / 5.1.2 / 5.2.1)</th></tr></thead><tbody><tr><td>Base triangles</td><td>3300–4000</td><td>3700 / 3700 / 3700</td></tr><tr><td>LOD1 ratio</td><td>0.32–0.62 of base</td><td>0.5000 / 0.5000 / 0.5000</td></tr><tr><td>LOD2 ratio</td><td>0.10–0.35 of base</td><td>0.2200 / 0.2200 / 0.2200</td></tr><tr><td>Materials</td><td>exactly 3 distinct; ≥24 wood, ≥24 metal, ≥6 water</td><td>3 slots; 1674 / 156 / 29</td></tr><tr><td>UVs</td><td>in <code>0..1</code>, AABB overlap ≤ 1e-5</td><td>in range, overlap 0</td></tr><tr><td>Outer AABB</td><td>(1.093, 0.552, 0.504) m ± 0.01</td><td>(1.0932, 0.5520, 0.5040), zmin 0</td></tr><tr><td>Collider tris</td><td>≤ 80</td><td>64</td></tr><tr><td>Export</td><td>written, size &gt; 0</td><td>268840 / 268840 / 268824 bytes</td></tr></tbody></table></div>
-<p>Base triangles rose from <strong>2484 to 3700</strong> in the quality pass: box end slabs and a single extruded U became ten jittered staves, U end-caps, continuous straps offset from the legs, and stretchers that meet the inner faces.</p>
-<p>DECIMATE COLLAPSE triangle counts are <strong>not</strong> identical across series — the gate is a ratio band, not an exact count. Bake pixels are stochastic; the gate is <code>has_data</code> plus operator <code>FINISHED</code>, not byte-identity. Stave-width jitter uses closed-form <code>sin(i)</code>, no RNG. Export byte counts differ by 16 B on 5.2.1 (glTF serializer), not a gated axis.</p>
+<div class="table-wrap"><table><thead><tr><th scope="col">Axis</th><th scope="col">Declared</th><th scope="col">Measured (4.5.11 / 5.1.2 / 5.2.1)</th></tr></thead><tbody><tr><td>Base triangles</td><td>2800–3500</td><td>3124 / 3124 / 3124</td></tr><tr><td>LOD1 ratio</td><td>0.32–0.62 of base</td><td>0.5000 / 0.5000 / 0.5000</td></tr><tr><td>LOD2 ratio</td><td>0.10–0.35 of base</td><td>0.2200 / 0.2200 / 0.2200</td></tr><tr><td>Materials</td><td>exactly 3 distinct; ≥24 wood, ≥24 metal, ≥6 water</td><td>3 slots; 1386 / 156 / 29</td></tr><tr><td>UVs</td><td>in <code>0..1</code>, AABB overlap ≤ 1e-5</td><td>in range, overlap 0</td></tr><tr><td>Outer AABB</td><td>(1.093, 0.552, 0.5055) m ± 0.01</td><td>(1.0932, 0.5520, 0.5055), zmin 0</td></tr><tr><td>Collider tris</td><td>≤ 80</td><td>64</td></tr><tr><td>Export</td><td>written, size &gt; 0</td><td>228520 / 228520 / 228504 bytes</td></tr></tbody></table></div>
+<p>Base triangles rose from <strong>2484 to 3700</strong> in the first quality pass: box end slabs and a single extruded U became ten jittered staves, U end-caps, continuous straps offset from the legs, and stretchers that meet the inner faces. The second pass took them to <strong>3124</strong>: the open U-band ends became solid end boards, which close the section with fewer faces.</p>
+<p>DECIMATE COLLAPSE triangle counts are <strong>not</strong> identical across series — the gate is a ratio band, not an exact count. Bake pixels are stochastic; the gate is <code>has_data</code> plus operator <code>FINISHED</code>, not byte-identity. Stave-width jitter uses closed-form <code>sin(i)</code>; plank tone is the only RNG, seeded (<code>TONE_SEED</code>). Export byte counts differ by 16 B on 5.2.1 (glTF serializer), not a gated axis.</p>
 <p>The hull-size budget (exit 19) runs <strong>before</strong> the outer AABB budget (exit 8) so <code>--narrow-hull</code> is not swallowed by a moved bounding box.</p>
 <h3>Hygiene</h3>
 <p>Recomputed from the generated mesh, not asserted about the script.</p>
 <div class="table-wrap"><table><thead><tr><th scope="col">Axis</th><th scope="col">Declared</th><th scope="col">Measured (all three)</th></tr></thead><tbody><tr><td>Non-manifold edges</td><td>0</td><td>0</td></tr><tr><td>Loose verts / edges</td><td>0 / 0</td><td>0 / 0</td></tr><tr><td>Doubles merged at 1e-5</td><td>0</td><td>0</td></tr><tr><td>Zero-area faces</td><td>0</td><td>0</td></tr><tr><td>N-gons</td><td>0</td><td>0</td></tr><tr><td>Coplanar disjoint face pairs</td><td>0</td><td>0</td></tr><tr><td>Grounded: <code>zmin</code></td><td>within 1e-4 of 0</td><td>0.0000</td></tr><tr><td>Named supports: 4 shoes</td><td>each <code>zmin</code> ≤ 0.001</td><td>4, shoe_z 0.00000</td></tr><tr><td>Hull plan</td><td>1.08 m × 0.44 m ± 0.08</td><td>1.0448 × 0.4661</td></tr></tbody></table></div>
 <h3>Joint fit and seat</h3>
-<div class="table-wrap"><table><thead><tr><th scope="col">Axis</th><th scope="col">Declared</th><th scope="col">Measured (all three)</th></tr></thead><tbody><tr><td>End-cap rim Z-span</td><td>≤ 0.080 m</td><td>0.0050</td></tr><tr><td>Strap-to-hull BVH gap</td><td>≤ 0.008 m</td><td>0.00000</td></tr><tr><td>Water-to-hull BVH gap</td><td>≤ 0.008 m</td><td>0.00260</td></tr></tbody></table></div>
+<div class="table-wrap"><table><thead><tr><th scope="col">Axis</th><th scope="col">Declared</th><th scope="col">Measured (all three)</th></tr></thead><tbody><tr><td>End-cap rim Z-span</td><td>≤ 0.080 m</td><td>0.0050</td></tr><tr><td>Strap-to-hull BVH gap</td><td>≤ 0.008 m</td><td>0.00000</td></tr><tr><td>Water-to-hull BVH gap</td><td>≤ 0.008 m</td><td>0.00260</td></tr><tr><td>Water contained by the end boards</td><td>0 misses over 66 outward rays</td><td>0 of 66</td></tr></tbody></table></div>
+<h3>Why the ends are solid boards</h3>
+<p>The first pass made each end a U-shaped band the staves tenoned into. That closed the rim and nothing else: the water&#x27;s own flat end face sat exposed where a board belongs, visible in the end orthos and the end-cap close-ups. Water in that trough would pour straight out, and with the ends open the piece read as a hammock or sling. The strap and water gap budgets passed throughout, because the water did touch the hull; nothing asked whether anything held it in at the ends.</p>
+<p><code>containment_audit</code> asks. From each water end face it casts rays outward along X, from the face&#x27;s perimeter vertices and from points drawn 50% and 90% of the way in from the centroid, so the middle of the section is tested and not only the rim a band would cover. Every ray must hit timber within <code>1.5 × END_T</code>. <code>--open-ends</code> restores the U-bands: all 66 rays miss, and the piece exits 18.</p>
+<h3>Surface</h3>
+<p>Staves, boards and legs came out of one flat material, so every board was the same board. <code>paint_planks</code> writes a seeded <code>PlankTone</code> and each shell&#x27;s own long axis as <code>GrainDir</code>, as face attributes. The wood shader stretches its grain along that axis. The water was a 0.08-roughness mirror that went near-white under the key. It is now a dark body with a facing-ratio sky tint toward grazing angles and a faint ripple bump. A light placed to reflect in the surface was tried first and rejected: it either mirrored as a white sheet or showed nothing, and its spill lifted the dark stage. The fill dropped from 68% to 50%, so the inner stave walls show above the waterline; at 68% the surface sat nearly flush with the rim and read as felt in a frame. Straps widened from 28 to 40 mm.</p>
 <h3>Falsifiers</h3>
-<p>Each violates one named budget. All seven were run on 4.5.11, 5.1.2 and 5.2.1 and returned the same code on each.</p>
-<div class="table-wrap"><table><thead><tr><th scope="col">Flag</th><th scope="col">Budget violated</th><th scope="col">Exit</th></tr></thead><tbody><tr><td><code>--skip-decimate</code></td><td>LOD1 ratio band</td><td>9</td></tr><tr><td><code>--stray-vert</code></td><td>loose vertex count is 0</td><td>15</td></tr><tr><td><code>--lift-z</code></td><td>bounding box <code>zmin</code> is 0</td><td>16</td></tr><tr><td><code>--short-legs</code></td><td>named shoe supports at Z=0</td><td>16</td></tr><tr><td><code>--box-ends</code></td><td>end-cap rim span</td><td>17</td></tr><tr><td><code>--float-strap</code></td><td>strap-to-hull gap</td><td>18</td></tr><tr><td><code>--narrow-hull</code></td><td>hull plan vs stated size</td><td>19</td></tr></tbody></table></div>
-<p><code>--short-legs</code> lifts the shoes only, so AABB <code>zmin</code> stays 0 (the legs still plant) and the named-support gate is what fires.</p>
+<p>Each violates one named budget. All eight were run on 4.5.11, 5.1.2 and 5.2.1 and returned the same code on each.</p>
+<div class="table-wrap"><table><thead><tr><th scope="col">Flag</th><th scope="col">Budget violated</th><th scope="col">Exit</th></tr></thead><tbody><tr><td><code>--skip-decimate</code></td><td>LOD1 ratio band</td><td>9</td></tr><tr><td><code>--stray-vert</code></td><td>loose vertex count is 0</td><td>15</td></tr><tr><td><code>--lift-z</code></td><td>bounding box <code>zmin</code> is 0</td><td>16</td></tr><tr><td><code>--short-legs</code></td><td>named shoe supports at Z=0</td><td>16</td></tr><tr><td><code>--box-ends</code></td><td>end-cap rim span</td><td>17</td></tr><tr><td><code>--float-strap</code></td><td>strap-to-hull gap</td><td>18</td></tr><tr><td><code>--narrow-hull</code></td><td>hull plan vs stated size</td><td>19</td></tr><tr><td><code>--open-ends</code></td><td>water contained by the end boards (restores the open U-band ends)</td><td>18</td></tr></tbody></table></div>
+<p><code>--short-legs</code> lifts the shoes and stretches each leg&#x27;s foot down to the floor, so AABB <code>zmin</code> stays 0 (the legs still plant) and the named-support gate is what fires. Lifting the shoes alone used to let the whole piece re-ground on the legs. That shrank the AABB by ~10 mm, 0.4 mm inside the bounding-box tolerance, and a 1.5 mm model change in this pass tipped it to exit 8. With the feet stretched, the envelope moves 1.6 mm.</p>
 <h2>Run</h2>
 <pre><code>blender --background --python water_trough.py --
 blender --background --python water_trough.py -- --skip-decimate
@@ -307,11 +312,12 @@ <h2>Run</h2>
 blender --background --python water_trough.py -- --box-ends
 blender --background --python water_trough.py -- --float-strap
 blender --background --python water_trough.py -- --narrow-hull
+blender --background --python water_trough.py -- --open-ends
 blender --background --python water_trough.py -- --output trough.png</code></pre>
 <p>Smoke passes no flags.</p>
 <h2>Exit codes</h2>
 <p>File-local. <code>9</code> is a valid check code. <code>10</code> is reserved for <code>gallery_framing.check_framing</code> on the <code>--output</code> path. <code>15</code>–<code>19</code> are the hygiene and joint-fit family.</p>
-<div class="table-wrap"><table><thead><tr><th scope="col">Code</th><th scope="col">Meaning</th></tr></thead><tbody><tr><td>0</td><td>Success</td></tr><tr><td>1</td><td>Uncaught exception (FATAL wrapper)</td></tr><tr><td>2</td><td>argparse / usage</td></tr><tr><td>3</td><td>Mesh did not build / no UV layer</td></tr><tr><td>4</td><td>Base triangle count outside range</td></tr><tr><td>5</td><td>Material count ≠ 3 distinct slots, or a face-count floor missed</td></tr><tr><td>6</td><td>UVs outside 0..1</td></tr><tr><td>7</td><td>UV AABB overlap above tolerance</td></tr><tr><td>8</td><td>World AABB off declared outer size</td></tr><tr><td>9</td><td>LOD ratio band (<code>--skip-decimate</code> lands here)</td></tr><tr><td>10</td><td>Framing gate (render path only)</td></tr><tr><td>11</td><td>Collider triangle count above ceiling</td></tr><tr><td>12</td><td>Bake did not finish or image has no data</td></tr><tr><td>13</td><td>Export file missing or empty</td></tr><tr><td>14</td><td><code>--output</code> produced no file</td></tr><tr><td>15</td><td>Mesh hygiene: loose, non-manifold, zero-area, doubles, n-gons, z-fight</td></tr><tr><td>16</td><td>Not grounded: bounding box <code>zmin</code> off 0, or a named shoe floats</td></tr><tr><td>17</td><td>Joint fit: end-cap U-rim span (<code>--box-ends</code>)</td></tr><tr><td>18</td><td>Seat: strap or water BVH gap (<code>--float-strap</code>)</td></tr><tr><td>19</td><td>Hull length or width off the stated real-world size (<code>--narrow-hull</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 / no UV layer</td></tr><tr><td>4</td><td>Base triangle count outside range</td></tr><tr><td>5</td><td>Material count ≠ 3 distinct slots, or a face-count floor missed</td></tr><tr><td>6</td><td>UVs outside 0..1</td></tr><tr><td>7</td><td>UV AABB overlap above tolerance</td></tr><tr><td>8</td><td>World AABB off declared outer size</td></tr><tr><td>9</td><td>LOD ratio band (<code>--skip-decimate</code> lands here)</td></tr><tr><td>10</td><td>Framing gate (render path only)</td></tr><tr><td>11</td><td>Collider triangle count above ceiling</td></tr><tr><td>12</td><td>Bake did not finish or image has no data</td></tr><tr><td>13</td><td>Export file missing or empty</td></tr><tr><td>14</td><td><code>--output</code> produced no file</td></tr><tr><td>15</td><td>Mesh hygiene: loose, non-manifold, zero-area, doubles, n-gons, z-fight</td></tr><tr><td>16</td><td>Not grounded: bounding box <code>zmin</code> off 0, or a named shoe floats</td></tr><tr><td>17</td><td>Joint fit: end-cap U-rim span (<code>--box-ends</code>)</td></tr><tr><td>18</td><td>Seat: strap or water BVH gap (<code>--float-strap</code>), or water not contained by the end boards (<code>--open-ends</code>)</td></tr><tr><td>19</td><td>Hull length or width off the stated real-world size (<code>--narrow-hull</code>)</td></tr></tbody></table></div>
     </section>
     <section class="detail-section src">
       <h2>Source</h2>
@@ -322,24 +328,26 @@ <h2>Source</h2>
       <pre><span class="s">&quot;&quot;&quot;Game-ready wooden water trough — a showcase piece, not an example.
 
 Asserts budget conformance of a procedural staved trough on a timber
-stand (U-staves and U end-caps from one radius function, contained
+stand (U-staves and solid end boards from one radius function, contained
 water, iron straps lofted on that same host, trestle legs) after
 composing shipped pipeline pieces: bmesh construction, UVs, three
 materials, high-to-low normal bake, LOD chain, convex collider, Unity
 glTF export.
 
-The hull, ends, straps and water all sample the same YZ arc. End caps
-are U-boards the staves tenon into, not a bounding-box slab around the
-U. Legs run from a hull-outer station to a shoe at Z=0.
+The hull, ends, straps and water all sample the same YZ arc. Each end
+is a solid board on the hull&#x27;s outer arc that the staves tenon into:
+not a bounding-box slab, not an open U-band. Legs run from a hull-outer station to a shoe at Z=0.
 
 Budgets are declared below and recomputed from the generated result.
 They are not API-contract witnesses. Each falsifier violates one named
 budget: ``--skip-decimate`` the LOD-ratio band, ``--stray-vert`` mesh
 hygiene, ``--lift-z`` grounded zmin, ``--short-legs`` named shoe
 supports, ``--box-ends`` end-cap U-fit, ``--float-strap`` strap seat,
-``--narrow-hull`` hull real-world size.
+``--narrow-hull`` hull real-world size, ``--open-ends`` water
+containment.
 
-No RNG. Stave seams use closed-form ``sin(i)``. DECIMATE COLLAPSE
+Stave seams use closed-form ``sin(i)``; the only RNG is plank tone,
+seeded with ``TONE_SEED``. DECIMATE COLLAPSE
 triangle counts are not byte-identical across Blender versions — the LOD
 gate is a ratio band, not an exact count.
 
@@ -350,6 +358,7 @@ <h2>Source</h2>
 <span class="k">import</span> argparse
 <span class="k">import</span> math
 <span class="k">import</span> os
+<span class="k">import</span> random
 <span class="k">import</span> sys
 <span class="k">import</span> tempfile
 <span class="k">import</span> traceback
@@ -374,7 +383,7 @@ <h2>Source</h2>
 END_T = <span class="n">0.044</span>
 END_OVERHANG = <span class="n">0.010</span>
 STAVE_GAP = <span class="n">0.008</span>
-STRAP_W = <span class="n">0.028</span>
+STRAP_W = <span class="n">0.040</span>
 STRAP_T = <span class="n">0.008</span>
 STRAP_BITE = <span class="n">0.008</span>
 SHOE_H = <span class="n">0.028</span>
@@ -387,15 +396,17 @@ <h2>Source</h2>
 STRETCHER_T = <span class="n">0.028</span>
 LEG_W = <span class="n">0.048</span>
 WATER_GAP = <span class="n">0.004</span>
-WATER_FILL = <span class="n">0.68</span>
+<span class="c"># Half full: at 0.68 the surface sat nearly flush with the rim and hid the</span>
+<span class="c"># inner stave walls, so nothing said vessel.</span>
+WATER_FILL = <span class="n">0.50</span>
 
 BBOX_TOL = <span class="n">0.01</span>
-OUTER_SIZE = (<span class="n">1.093</span>, <span class="n">0.552</span>, <span class="n">0.504</span>)
+OUTER_SIZE = (<span class="n">1.093</span>, <span class="n">0.552</span>, <span class="n">0.5055</span>)
 HULL_SIZE = (<span class="n">1.08</span>, <span class="n">0.44</span>)
 HULL_SIZE_TOL = (<span class="n">0.08</span>, <span class="n">0.08</span>)
 NARROW_HULL_R = <span class="n">0.12</span>
-BASE_TRIS_MIN = <span class="n">3300</span>
-BASE_TRIS_MAX = <span class="n">4000</span>
+BASE_TRIS_MIN = <span class="n">2800</span>
+BASE_TRIS_MAX = <span class="n">3500</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>
@@ -429,6 +440,15 @@ <h2>Source</h2>
 METAL_IDX = <span class="n">1</span>
 WATER_IDX = <span class="n">2</span>
 
+<span class="c"># Water containment: rays cast outward along X from points across each end</span>
+<span class="c"># face of the water must hit an end board within this reach. The ends used</span>
+<span class="c"># to be open U-bands; the water&#x27;s own end face showed where a board belongs</span>
+<span class="c"># and nothing held it in.</span>
+CONTAIN_REACH = END_T * <span class="n">1.5</span>
+CONTAIN_FRACS = (<span class="n">0.0</span>, <span class="n">0.5</span>, <span class="n">0.9</span>)
+PLANK_TONE_JITTER = <span class="n">0.28</span>
+TONE_SEED = <span class="n">61</span>
+
 
 <span class="k">def</span> eevee_engine_id():
     <span class="k">return</span> <span class="s">&quot;BLENDER_EEVEE&quot;</span> <span class="k">if</span> bpy.app.version &gt;= (<span class="n">5</span>, <span class="n">0</span>, <span class="n">0</span>) <span class="k">else</span> <span class="s">&quot;BLENDER_EEVEE_NEXT&quot;</span>
@@ -548,6 +568,38 @@ <h2>Source</h2>
     <span class="k">return</span> r0 + r1
 
 
+<span class="k">def</span> add_end_board(bm, x0, x1, r_arc, z_top, n_seg, zc, a_span, mat_idx):
+    <span class="s">&quot;&quot;&quot;A solid end board: the hull&#x27;s own outer arc below, a level top above.
+
+    The profile is closed with vertical strips from each arc point up to
+    ``z_top``, so every face is a quad and there is no n-gon to fan. The
+    bottom follows the hull arc, which is what separates it from the
+    bounding-box slab ``--box-ends`` builds.
+    &quot;&quot;&quot;</span>
+    <span class="k">def</span> ring(x):
+        arc = []
+        top = []
+        <span class="k">for</span> i <span class="k">in</span> range(n_seg + <span class="n">1</span>):
+            a = -a_span + <span class="n">2.0</span> * a_span * i / n_seg
+            p = _arc_point(a, r_arc, x, zc)
+            arc.append(bm.verts.new(p))
+            top.append(bm.verts.new((x, p.y, z_top)))
+        <span class="k">return</span> arc, top
+
+    arc0, top0 = ring(x0)
+    arc1, top1 = ring(x1)
+    verts = arc0 + top0 + arc1 + top1
+    <span class="k">for</span> i <span class="k">in</span> range(n_seg):
+        j = i + <span class="n">1</span>
+        _face(bm, (arc0[i], top0[i], top0[j], arc0[j]), mat_idx)
+        _face(bm, (arc1[j], top1[j], top1[i], arc1[i]), mat_idx)
+        _face(bm, (arc0[j], arc1[j], arc1[i], arc0[i]), mat_idx)
+        _face(bm, (top0[i], top1[i], top1[j], top0[j]), mat_idx)
+    _face(bm, (arc0[<span class="n">0</span>], arc1[<span class="n">0</span>], top1[<span class="n">0</span>], top0[<span class="n">0</span>]), mat_idx)
+    _face(bm, (arc0[n_seg], top0[n_seg], top1[n_seg], arc1[n_seg]), mat_idx)
+    <span class="k">return</span> verts
+
+
 <span class="k">def</span> add_box_end(bm, x_mid, radius, zc, a_span, thick, mat_idx):
     y_span = <span class="n">2.0</span> * radius * math.sin(a_span)
     z_lo = zc - radius
@@ -638,6 +690,7 @@ <h2>Source</h2>
     float_strap=<span class="k">False</span>,
     short_legs=<span class="k">False</span>,
     narrow_hull=<span class="k">False</span>,
+    open_ends=<span class="k">False</span>,
 ):
     bm = bmesh.new()
     <span class="k">try</span>:
@@ -666,19 +719,26 @@ <h2>Source</h2>
             )
             a = a1 + STAVE_GAP
 
-        <span class="k">if</span> <span class="k">not</span> box_ends:
-            r_cap_in = r_in - <span class="n">0.006</span>
-            r_cap_out = r_out + END_OVERHANG
-            wood.extend(
-                add_u_shell(
-                    bm, x_cap_l0, x_cap_l1, r_cap_in, r_cap_out, N_STAVES, zc, A_SPAN, WOOD_IDX
+        r_cap_in = r_in - <span class="n">0.006</span>
+        r_cap_out = r_out + END_OVERHANG
+        <span class="k">if</span> open_ends:
+            <span class="c"># The pre-pass end: a U-band the staves tenon into, open in the</span>
+            <span class="c"># middle. --open-ends restores it as the containment falsifier.</span>
+            <span class="k">for</span> xa, xb <span class="k">in</span> ((x_cap_l0, x_cap_l1), (x_cap_r0, x_cap_r1)):
+                wood.extend(
+                    add_u_shell(
+                        bm, xa, xb, r_cap_in, r_cap_out, N_STAVES, zc, A_SPAN, WOOD_IDX
+                    )
                 )
-            )
-            wood.extend(
-                add_u_shell(
-                    bm, x_cap_r0, x_cap_r1, r_cap_in, r_cap_out, N_STAVES, zc, A_SPAN, WOOD_IDX
+        <span class="k">elif</span> <span class="k">not</span> box_ends:
+            <span class="c"># Top sits at the band&#x27;s inner rim, 6 mm proud of the staves.</span>
+            z_top = zc - r_cap_in * math.cos(A_SPAN)
+            <span class="k">for</span> xa, xb <span class="k">in</span> ((x_cap_l0, x_cap_l1), (x_cap_r0, x_cap_r1)):
+                wood.extend(
+                    add_end_board(
+                        bm, xa, xb, r_cap_out, z_top, N_STAVES, zc, A_SPAN, WOOD_IDX
+                    )
                 )
-            )
 
         top_z = hull_z_at_y(LEG_TOP_Y, r_out, zc)
         bot_z = SHOE_H * <span class="n">0.55</span>
@@ -691,7 +751,21 @@ <h2>Source</h2>
                 bot_pt = Vector((sx, ysign * LEG_BOT_Y, bot_z))
                 direction = (top_pt - bot_pt).normalized()
                 top_pt = top_pt + direction * (STAVE_T * <span class="n">0.35</span>)
-                wood.extend(add_oriented_box(bm, top_pt, bot_pt, (LEG_W, <span class="n">0.034</span>), WOOD_IDX))
+                leg = add_oriented_box(bm, top_pt, bot_pt, (LEG_W, <span class="n">0.034</span>), WOOD_IDX)
+                <span class="k">if</span> short_legs:
+                    <span class="c"># The legs, not the shoes, must plant: stretch each leg&#x27;s</span>
+                    <span class="c"># foot down to the floor so the lifted shoes float while</span>
+                    <span class="c"># the piece keeps the same floor and envelope. Lifting the</span>
+                    <span class="c"># shoes alone let the whole piece re-ground on the legs,</span>
+                    <span class="c"># shrinking the AABB ~10 mm; that sat 0.4 mm inside the</span>
+                    <span class="c"># bbox tolerance and tipped to exit 8 on a 1.5 mm model</span>
+                    <span class="c"># change.</span>
+                    zmid = <span class="n">0.5</span> * (top_pt.z + bot_pt.z)
+                    foot = [v <span class="k">for</span> v <span class="k">in</span> leg <span class="k">if</span> v.co.z &lt; zmid]
+                    drop = min(v.co.z <span class="k">for</span> v <span class="k">in</span> foot)
+                    <span class="k">for</span> v <span class="k">in</span> foot:
+                        v.co.z -= drop
+                wood.extend(leg)
             t_st = (STRETCHER_Z - bot_z) / max(top_z - bot_z, <span class="n">1e-6</span>)
             y_leg = LEG_BOT_Y + t_st * (LEG_TOP_Y - LEG_BOT_Y)
             <span class="c"># Inner face of the diagonal leg, not through its volume.</span>
@@ -715,7 +789,12 @@ <h2>Source</h2>
         )
 
         <span class="k">if</span> bevel_offset &gt; <span class="n">0.0</span>:
-            edges = list({e <span class="k">for</span> v <span class="k">in</span> wood <span class="k">for</span> e <span class="k">in</span> v.link_edges})
+            <span class="c"># Flat edges (the strip seams across an end board&#x27;s face) are</span>
+            <span class="c"># not corners; chamfering one creases a flat face.</span>
+            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> wood <span class="k">for</span> e <span class="k">in</span> v.link_edges}
+                <span class="k">if</span> <span class="k">not</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>) &lt; <span class="n">1e-4</span>)
+            ]
             ret = bmesh.ops.bevel(
                 bm,
                 geom=edges,
@@ -800,11 +879,58 @@ <h2>Source</h2>
             poly.use_smooth = <span class="k">False</span>
     <span class="k">finally</span>:
         bm.free()
+    paint_planks(me)
     out = bpy.data.objects.new(name, me)
     bpy.context.collection.objects.link(out)
     <span class="k">return</span> out
 
 
+<span class="k">def</span> _long_axis(pts):
+    <span class="s">&quot;&quot;&quot;Principal axis of a point set, by power iteration on its covariance.&quot;&quot;&quot;</span>
+    n = len(pts)
+    c = sum(pts, Vector()) / n
+    cov = [[<span class="n">0.0</span>] * <span class="n">3</span> <span class="k">for</span> _ <span class="k">in</span> range(<span class="n">3</span>)]
+    <span class="k">for</span> p <span class="k">in</span> pts:
+        d = p - c
+        <span class="k">for</span> i <span class="k">in</span> range(<span class="n">3</span>):
+            <span class="k">for</span> j <span class="k">in</span> range(<span class="n">3</span>):
+                cov[i][j] += d[i] * d[j]
+    v = Vector((<span class="n">1.0</span>, <span class="n">0.3</span>, <span class="n">0.1</span>))
+    <span class="k">for</span> _ <span class="k">in</span> range(<span class="n">30</span>):
+        w = Vector([sum(cov[i][j] * v[j] <span class="k">for</span> j <span class="k">in</span> range(<span class="n">3</span>)) <span class="k">for</span> i <span class="k">in</span> range(<span class="n">3</span>)])
+        <span class="k">if</span> w.length &lt; <span class="n">1e-12</span>:
+            <span class="k">break</span>
+        v = w.normalized()
+    <span class="k">return</span> v
+
+
+<span class="k">def</span> paint_planks(me):
+    <span class="s">&quot;&quot;&quot;Per-shell tone and grain direction, as face attributes.
+
+    Staves, end boards and legs came out of one flat material, so every
+    board was the same board. The wood shader stretches its grain along
+    ``GrainDir`` (each shell&#x27;s own long axis) and shades by ``PlankTone``.
+    &quot;&quot;&quot;</span>
+    tone = [<span class="n">0.5</span>] * len(me.polygons)
+    grain = [(<span class="n">1.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>)] * len(me.polygons)
+    owner = {}
+    rng = random.Random(TONE_SEED)
+    <span class="k">for</span> g <span class="k">in</span> shells(me):
+        pts = [me.vertices[i].co.copy() <span class="k">for</span> i <span class="k">in</span> g]
+        d = _long_axis(pts) <span class="k">if</span> len(pts) &gt; <span class="n">2</span> <span class="k">else</span> Vector((<span class="n">1.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>))
+        t = <span class="n">0.5</span> + rng.uniform(-PLANK_TONE_JITTER, PLANK_TONE_JITTER)
+        <span class="k">for</span> i <span class="k">in</span> g:
+            owner[i] = (t, tuple(d))
+    <span class="k">for</span> poly <span class="k">in</span> me.polygons:
+        t, d = owner[poly.vertices[<span class="n">0</span>]]
+        tone[poly.index] = t
+        grain[poly.index] = d
+    a = me.attributes.new(<span class="s">&quot;PlankTone&quot;</span>, <span class="s">&quot;FLOAT&quot;</span>, <span class="s">&quot;FACE&quot;</span>)
+    a.data.foreach_set(<span class="s">&quot;value&quot;</span>, tone)
+    b = me.attributes.new(<span class="s">&quot;GrainDir&quot;</span>, <span class="s">&quot;FLOAT_VECTOR&quot;</span>, <span class="s">&quot;FACE&quot;</span>)
+    b.data.foreach_set(<span class="s">&quot;vector&quot;</span>, [c <span class="k">for</span> v <span class="k">in</span> grain <span class="k">for</span> c <span class="k">in</span> v])
+
+
 <span class="k">def</span> principled(name, color, metallic, roughness, roughness_var=<span class="n">0.0</span>):
     mat = bpy.data.materials.new(name)
     mat.use_nodes = <span class="k">True</span>
@@ -828,6 +954,119 @@ <h2>Source</h2>
     <span class="k">return</span> mat
 
 
+<span class="k">def</span> _sock(sockets, identifier):
+    <span class="s">&quot;&quot;&quot;A Mix-node socket by identifier; its A/B/Result names repeat per type.&quot;&quot;&quot;</span>
+    <span class="k">return</span> next(sk <span class="k">for</span> sk <span class="k">in</span> sockets <span class="k">if</span> sk.identifier == identifier)
+
+
+<span class="k">def</span> wood_material(name):
+    <span class="s">&quot;&quot;&quot;Grain along each board (``GrainDir``), tone per board (``PlankTone``).&quot;&quot;&quot;</span>
+    mat = bpy.data.materials.new(name)
+    mat.use_nodes = <span class="k">True</span>
+    nt = mat.node_tree
+    bsdf = nt.nodes[<span class="s">&quot;Principled BSDF&quot;</span>]
+    coord = nt.nodes.new(<span class="s">&quot;ShaderNodeTexCoord&quot;</span>)
+    gdir = nt.nodes.new(<span class="s">&quot;ShaderNodeAttribute&quot;</span>)
+    gdir.attribute_name = <span class="s">&quot;GrainDir&quot;</span>
+    tone = nt.nodes.new(<span class="s">&quot;ShaderNodeAttribute&quot;</span>)
+    tone.attribute_name = <span class="s">&quot;PlankTone&quot;</span>
+    dot = nt.nodes.new(<span class="s">&quot;ShaderNodeVectorMath&quot;</span>)
+    dot.operation = <span class="s">&quot;DOT_PRODUCT&quot;</span>
+    nt.links.new(coord.outputs[<span class="s">&quot;Object&quot;</span>], dot.inputs[<span class="n">0</span>])
+    nt.links.new(gdir.outputs[<span class="s">&quot;Vector&quot;</span>], dot.inputs[<span class="n">1</span>])
+    squash = nt.nodes.new(<span class="s">&quot;ShaderNodeMath&quot;</span>)
+    squash.operation = <span class="s">&quot;MULTIPLY&quot;</span>
+    squash.inputs[<span class="n">1</span>].default_value = <span class="n">0.94</span>
+    nt.links.new(dot.outputs[<span class="s">&quot;Value&quot;</span>], squash.inputs[<span class="n">0</span>])
+    along = nt.nodes.new(<span class="s">&quot;ShaderNodeVectorMath&quot;</span>)
+    along.operation = <span class="s">&quot;SCALE&quot;</span>
+    nt.links.new(gdir.outputs[<span class="s">&quot;Vector&quot;</span>], along.inputs[<span class="n">0</span>])
+    nt.links.new(squash.outputs[<span class="s">&quot;Value&quot;</span>], along.inputs[<span class="s">&quot;Scale&quot;</span>])
+    grain_co = nt.nodes.new(<span class="s">&quot;ShaderNodeVectorMath&quot;</span>)
+    grain_co.operation = <span class="s">&quot;SUBTRACT&quot;</span>
+    nt.links.new(coord.outputs[<span class="s">&quot;Object&quot;</span>], grain_co.inputs[<span class="n">0</span>])
+    nt.links.new(along.outputs[<span class="s">&quot;Vector&quot;</span>], grain_co.inputs[<span class="n">1</span>])
+    shift = nt.nodes.new(<span class="s">&quot;ShaderNodeVectorMath&quot;</span>)
+    shift.operation = <span class="s">&quot;ADD&quot;</span>
+    nt.links.new(grain_co.outputs[<span class="s">&quot;Vector&quot;</span>], shift.inputs[<span class="n">0</span>])
+    nt.links.new(tone.outputs[<span class="s">&quot;Fac&quot;</span>], shift.inputs[<span class="n">1</span>])
+    noise = nt.nodes.new(<span class="s">&quot;ShaderNodeTexNoise&quot;</span>)
+    noise.inputs[<span class="s">&quot;Scale&quot;</span>].default_value = <span class="n">30.0</span>
+    noise.inputs[<span class="s">&quot;Detail&quot;</span>].default_value = <span class="n">6.0</span>
+    noise.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.62</span>
+    nt.links.new(shift.outputs[<span class="s">&quot;Vector&quot;</span>], noise.inputs[<span class="s">&quot;Vector&quot;</span>])
+    ramp = nt.nodes.new(<span class="s">&quot;ShaderNodeValToRGB&quot;</span>)
+    ramp.color_ramp.elements[<span class="n">0</span>].position = <span class="n">0.30</span>
+    ramp.color_ramp.elements[<span class="n">0</span>].color = (<span class="n">0.13</span>, <span class="n">0.062</span>, <span class="n">0.024</span>, <span class="n">1.0</span>)
+    ramp.color_ramp.elements[<span class="n">1</span>].position = <span class="n">0.72</span>
+    ramp.color_ramp.elements[<span class="n">1</span>].color = (<span class="n">0.40</span>, <span class="n">0.21</span>, <span class="n">0.085</span>, <span class="n">1.0</span>)
+    nt.links.new(noise.outputs[<span class="s">&quot;Fac&quot;</span>], ramp.inputs[<span class="s">&quot;Fac&quot;</span>])
+    gain = nt.nodes.new(<span class="s">&quot;ShaderNodeMath&quot;</span>)
+    gain.operation = <span class="s">&quot;MULTIPLY_ADD&quot;</span>
+    gain.inputs[<span class="n">1</span>].default_value = <span class="n">1.1</span>
+    gain.inputs[<span class="n">2</span>].default_value = <span class="n">0.45</span>
+    nt.links.new(tone.outputs[<span class="s">&quot;Fac&quot;</span>], gain.inputs[<span class="n">0</span>])
+    mix = nt.nodes.new(<span class="s">&quot;ShaderNodeMix&quot;</span>)
+    mix.data_type = <span class="s">&quot;RGBA&quot;</span>
+    mix.blend_type = <span class="s">&quot;MULTIPLY&quot;</span>
+    _sock(mix.inputs, <span class="s">&quot;Factor_Float&quot;</span>).default_value = <span class="n">1.0</span>
+    nt.links.new(ramp.outputs[<span class="s">&quot;Color&quot;</span>], _sock(mix.inputs, <span class="s">&quot;A_Color&quot;</span>))
+    nt.links.new(gain.outputs[<span class="s">&quot;Value&quot;</span>], _sock(mix.inputs, <span class="s">&quot;B_Color&quot;</span>))
+    nt.links.new(_sock(mix.outputs, <span class="s">&quot;Result_Color&quot;</span>), bsdf.inputs[<span class="s">&quot;Base Color&quot;</span>])
+    rough = nt.nodes.new(<span class="s">&quot;ShaderNodeMapRange&quot;</span>)
+    rough.inputs[<span class="s">&quot;To Min&quot;</span>].default_value = <span class="n">0.72</span>
+    rough.inputs[<span class="s">&quot;To Max&quot;</span>].default_value = <span class="n">0.52</span>
+    nt.links.new(noise.outputs[<span class="s">&quot;Fac&quot;</span>], rough.inputs[<span class="s">&quot;Value&quot;</span>])
+    nt.links.new(rough.outputs[<span class="s">&quot;Result&quot;</span>], bsdf.inputs[<span class="s">&quot;Roughness&quot;</span>])
+    <span class="k">return</span> mat
+
+
+<span class="k">def</span> water_material(name):
+    <span class="s">&quot;&quot;&quot;Dark, clear-reading water with a faint ripple.
+
+    The old flat 0.08-roughness teal was a mirror: under the key it went
+    near-white and, with open ends, read as a stretched fabric sling. A
+    darker body and a small noise bump break the reflection into a surface.
+    &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;Roughness&quot;</span>].default_value = <span class="n">0.06</span>
+    bsdf.inputs[<span class="s">&quot;IOR&quot;</span>].default_value = <span class="n">1.33</span>
+    <span class="c"># Deep body where the view looks straight down, a pale sky tint toward</span>
+    <span class="c"># grazing angles. A light placed to reflect in the surface was</span>
+    <span class="c"># all-or-nothing (white mirror or nothing) and flooded the dark stage;</span>
+    <span class="c"># a facing-ratio tint gives the sheen without touching the lighting.</span>
+    facing = nt.nodes.new(<span class="s">&quot;ShaderNodeLayerWeight&quot;</span>)
+    facing.inputs[<span class="s">&quot;Blend&quot;</span>].default_value = <span class="n">0.55</span>
+    tint = nt.nodes.new(<span class="s">&quot;ShaderNodeMix&quot;</span>)
+    tint.data_type = <span class="s">&quot;RGBA&quot;</span>
+    _sock(tint.inputs, <span class="s">&quot;A_Color&quot;</span>).default_value = (<span class="n">0.010</span>, <span class="n">0.040</span>, <span class="n">0.046</span>, <span class="n">1.0</span>)
+    _sock(tint.inputs, <span class="s">&quot;B_Color&quot;</span>).default_value = (<span class="n">0.20</span>, <span class="n">0.27</span>, <span class="n">0.29</span>, <span class="n">1.0</span>)
+    nt.links.new(facing.outputs[<span class="s">&quot;Facing&quot;</span>], _sock(tint.inputs, <span class="s">&quot;Factor_Float&quot;</span>))
+    nt.links.new(_sock(tint.outputs, <span class="s">&quot;Result_Color&quot;</span>), bsdf.inputs[<span class="s">&quot;Base Color&quot;</span>])
+    coord = nt.nodes.new(<span class="s">&quot;ShaderNodeTexCoord&quot;</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">22.0</span>
+    noise.inputs[<span class="s">&quot;Detail&quot;</span>].default_value = <span class="n">3.0</span>
+    nt.links.new(coord.outputs[<span class="s">&quot;Object&quot;</span>], noise.inputs[<span class="s">&quot;Vector&quot;</span>])
+    bump = nt.nodes.new(<span class="s">&quot;ShaderNodeBump&quot;</span>)
+    bump.inputs[<span class="s">&quot;Strength&quot;</span>].default_value = <span class="n">0.08</span>
+    bump.inputs[<span class="s">&quot;Distance&quot;</span>].default_value = <span class="n">0.004</span>
+    nt.links.new(noise.outputs[<span class="s">&quot;Fac&quot;</span>], bump.inputs[<span class="s">&quot;Height&quot;</span>])
+    nt.links.new(bump.outputs[<span class="s">&quot;Normal&quot;</span>], bsdf.inputs[<span class="s">&quot;Normal&quot;</span>])
+    <span class="k">return</span> mat
+
+
+<span class="k">def</span> trough_materials():
+    <span class="s">&quot;&quot;&quot;(wood, iron, water): shared by the check, the render and inspection.&quot;&quot;&quot;</span>
+    wood = wood_material(<span class="s">&quot;TroughWood&quot;</span>)
+    metal = principled(<span class="s">&quot;TroughIron&quot;</span>, (<span class="n">0.16</span>, <span class="n">0.155</span>, <span class="n">0.15</span>, <span class="n">1.0</span>), <span class="n">0.85</span>, <span class="n">0.42</span>, roughness_var=<span class="n">0.10</span>)
+    water = water_material(<span class="s">&quot;TroughWater&quot;</span>)
+    <span class="k">return</span> wood, metal, water
+
+
 <span class="k">def</span> assign_slots(obj, wood, metal, water):
     mats = obj.data.materials
     wanted = (wood, metal, water)
@@ -1100,6 +1339,43 @@ <h2>Source</h2>
     }
 
 
+<span class="k">def</span> containment_audit(me):
+    <span class="s">&quot;&quot;&quot;Rays outward along X from across each water end face must hit a board.
+
+    Samples each end face at its perimeter vertices and at points drawn
+    toward the face centroid (CONTAIN_FRACS), so the middle of the section
+    is tested, not only the rim a U-band would cover. A miss is water with
+    nothing holding it in.
+    &quot;&quot;&quot;</span>
+    water_v = {i <span class="k">for</span> p <span class="k">in</span> me.polygons <span class="k">if</span> p.material_index == WATER_IDX <span class="k">for</span> i <span class="k">in</span> p.vertices}
+    <span class="k">if</span> <span class="k">not</span> water_v:
+        <span class="k">return</span> {<span class="s">&quot;rays&quot;</span>: <span class="n">0</span>, <span class="s">&quot;misses&quot;</span>: <span class="n">1</span>}
+    bm = bmesh.new()
+    <span class="k">try</span>:
+        bm.from_mesh(me)
+        drop = [f <span class="k">for</span> f <span class="k">in</span> bm.faces <span class="k">if</span> f.material_index != WOOD_IDX]
+        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()
+    pts = [me.vertices[i].co <span class="k">for</span> i <span class="k">in</span> water_v]
+    xmin = min(p.x <span class="k">for</span> p <span class="k">in</span> pts)
+    xmax = max(p.x <span class="k">for</span> p <span class="k">in</span> pts)
+    rays = misses = <span class="n">0</span>
+    <span class="k">for</span> x_end, out <span class="k">in</span> ((xmin, -<span class="n">1.0</span>), (xmax, <span class="n">1.0</span>)):
+        face = [p <span class="k">for</span> p <span class="k">in</span> pts <span class="k">if</span> abs(p.x - x_end) &lt; <span class="n">1e-5</span>]
+        c = sum(face, Vector()) / len(face)
+        <span class="k">for</span> p <span class="k">in</span> face:
+            <span class="k">for</span> t <span class="k">in</span> CONTAIN_FRACS:
+                q = c + (p - c) * t
+                origin = Vector((x_end - out * <span class="n">1e-4</span>, q.y, q.z))
+                hit = tree.ray_cast(origin, Vector((out, <span class="n">0.0</span>, <span class="n">0.0</span>)), CONTAIN_REACH)
+                rays += <span class="n">1</span>
+                <span class="k">if</span> hit[<span class="n">0</span>] <span class="k">is</span> <span class="k">None</span>:
+                    misses += <span class="n">1</span>
+    <span class="k">return</span> {<span class="s">&quot;rays&quot;</span>: rays, <span class="s">&quot;misses&quot;</span>: misses}
+
+
 <span class="k">def</span> add_stray_vert(me):
     bm = bmesh.new()
     <span class="k">try</span>:
@@ -1205,6 +1481,7 @@ <h2>Source</h2>
     float_strap=<span class="k">False</span>,
     short_legs=<span class="k">False</span>,
     narrow_hull=<span class="k">False</span>,
+    open_ends=<span class="k">False</span>,
 ):
     bpy.ops.wm.read_factory_settings(use_empty=<span class="k">True</span>)
     low = build_trough_mesh(
@@ -1215,6 +1492,7 @@ <h2>Source</h2>
         float_strap=float_strap,
         short_legs=short_legs,
         narrow_hull=narrow_hull,
+        open_ends=open_ends,
     )
     high = build_trough_mesh(
         <span class="s">&quot;TroughHigh&quot;</span>,
@@ -1224,10 +1502,9 @@ <h2>Source</h2>
         float_strap=float_strap,
         short_legs=short_legs,
         narrow_hull=narrow_hull,
+        open_ends=open_ends,
     )
-    wood = principled(<span class="s">&quot;TroughWood&quot;</span>, (<span class="n">0.40</span>, <span class="n">0.22</span>, <span class="n">0.08</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.58</span>, roughness_var=<span class="n">0.10</span>)
-    metal = principled(<span class="s">&quot;TroughIron&quot;</span>, (<span class="n">0.10</span>, <span class="n">0.105</span>, <span class="n">0.12</span>, <span class="n">1.0</span>), <span class="n">1.0</span>, <span class="n">0.32</span>, roughness_var=<span class="n">0.08</span>)
-    water = principled(<span class="s">&quot;TroughWater&quot;</span>, (<span class="n">0.06</span>, <span class="n">0.16</span>, <span class="n">0.18</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.08</span>)
+    wood, metal, water = trough_materials()
     assign_slots(low, wood, metal, water)
     assign_slots(high, wood, metal, water)
 
@@ -1258,6 +1535,7 @@ <h2>Source</h2>
     zf = zfight_pairs(low.data)
     sup = support_audit(low.data)
     jnt = joint_audit(low.data)
+    con = containment_audit(low.data)
 
     img, tex = setup_bake_image(low, wood)
     <span class="k">if</span> img <span class="k">is</span> <span class="k">None</span>:
@@ -1285,6 +1563,10 @@ <h2>Source</h2>
         os.remove(export_path)
     export_unity(export_path, [low, collider])
     export_size = os.path.getsize(export_path) <span class="k">if</span> os.path.isfile(export_path) <span class="k">else</span> <span class="n">0</span>
+    <span class="c"># Blender points TMPDIR at its own temp preference, which on a portable</span>
+    <span class="c"># build is the working directory, so the export must not outlive this.</span>
+    <span class="k">if</span> os.path.isfile(export_path):
+        os.remove(export_path)
 
     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(
@@ -1314,6 +1596,7 @@ <h2>Source</h2>
         <span class="s">f&quot;</span><span class="s">water_gap=</span>{jnt[<span class="s">&#x27;water_gap&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> hull_xy=</span>{jnt[<span class="s">&#x27;hull_xy&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
         <span class="s">f&quot;</span><span class="s">ends=</span>{jnt[<span class="s">&#x27;ends&#x27;</span>]}<span class="s"> straps=</span>{jnt[<span class="s">&#x27;straps&#x27;</span>]}<span class="s">&quot;</span>
     )
+    print(<span class="s">f&quot;</span><span class="s">measured containment rays=</span>{con[<span class="s">&#x27;rays&#x27;</span>]}<span class="s"> misses=</span>{con[<span class="s">&#x27;misses&#x27;</span>]}<span class="s">&quot;</span>)
 
     <span class="k">if</span> <span class="k">not</span> (BASE_TRIS_MIN &lt;= base_tris &lt;= BASE_TRIS_MAX):
         <span class="k">return</span> fail(
@@ -1429,6 +1712,13 @@ <h2>Source</h2>
             <span class="s">f&quot;</span><span class="s">water-hull gap </span>{jnt[<span class="s">&#x27;water_gap&#x27;</span>]:<span class="s">.5f</span>}<span class="s">&quot;</span>,
             <span class="n">18</span>,
         ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+    <span class="k">if</span> con[<span class="s">&quot;rays&quot;</span>] == <span class="n">0</span> <span class="k">or</span> con[<span class="s">&quot;misses&quot;</span>]:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">water not contained: </span>{con[<span class="s">&#x27;misses&#x27;</span>]}<span class="s"> of </span>{con[<span class="s">&#x27;rays&#x27;</span>]}<span class="s"> outward rays </span><span class="s">&quot;</span>
+            <span class="s">&quot;from the water end faces hit no end board &quot;</span>
+            <span class="s">&quot;(--open-ends is the designed fail)&quot;</span>,
+            <span class="n">18</span>,
+        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
     <span class="k">return</span> <span class="n">0</span>, low, high, wood, tex, collider
 
 
@@ -1549,6 +1839,7 @@ <h2>Source</h2>
     p.add_argument(<span class="s">&quot;--box-ends&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
     p.add_argument(<span class="s">&quot;--float-strap&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
     p.add_argument(<span class="s">&quot;--narrow-hull&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--open-ends&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
     args = p.parse_args(argv)
 
     code, low, _high, wood, tex, _col = check(
@@ -1559,6 +1850,7 @@ <h2>Source</h2>
         float_strap=args.float_strap,
         short_legs=args.short_legs,
         narrow_hull=args.narrow_hull,
+        open_ends=args.open_ends,
     )
     <span class="k">if</span> code:
         <span class="k">return</span> code
@@ -1583,7 +1875,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/water-trough-hero.webp" alt="A curved wooden water trough on crossed trestle legs, filled with dark green water." />
+    <img src="../assets/water-trough-hero.webp" alt="A staved wooden water trough with solid half-round end boards on crossed trestle legs, half full of dark water." />
   </dialog>
   <footer>
     <div class="statusbar">
diff --git a/examples/eval-mesh-datablock-name/README.md b/examples/eval-mesh-datablock-name/README.md
index a3063ec7..2c67937b 100644
--- a/examples/eval-mesh-datablock-name/README.md
+++ b/examples/eval-mesh-datablock-name/README.md
@@ -39,6 +39,55 @@ which is red on every binary.
 
 No `SMOKE_SKIP`. Every matrix leg exercises the contract.
 
+## Who hits this
+
+Exporters, bakers and measurement scripts that receive "some mesh" and
+decide whether it is the evaluated result or the original by comparing
+names: `if mesh.name != obj.data.name: # evaluated`. On 5.2 that branch
+never fires for a modified object, and nothing raises. The script
+silently treats evaluated geometry as original: it writes the
+modifier-free count into a report, or skips a `to_mesh_clear()` it
+thinks it does not owe.
+
+**It was never a reliable test.** Re-measured with the modifier removed,
+`evaluated_get().data.name` equals the source name on **all three**
+binaries, 4.5.11 included. On 4.5 and 5.1 the inequality held only for
+objects whose modifiers produced a new mesh. The 5.2 change removed the
+last case where it happened to work.
+
+**What to do instead.** Do not infer "evaluated" from the datablock. The
+caller knows which object it evaluated: keep that reference and branch on
+where the mesh came from, not on what it is called. Two obvious ID
+properties are no substitute. In a probe on the same SUBSURF cube,
+`ID.is_evaluated` read `False` on the evaluated mesh, and `ID.original`
+did not compare equal to the source mesh, on 4.5.11, 5.1.2 and 5.2.1
+alike. Neither is offered here as a replacement.
+
+## Re-verified
+
+| Measurement | 4.5.11 | 5.1.2 | 5.2.1 |
+| --- | --- | --- | --- |
+| `evaluated_get().data.name`, SUBSURF | `Mesh` | `Mesh` | `SourceMesh` |
+| `evaluated_get().data.name`, no modifier | `SourceMesh` | `SourceMesh` | `SourceMesh` |
+| `to_mesh().name` | `SourceMesh` | `SourceMesh` | `SourceMesh` |
+| Evaluated verts (SUBSURF / none) | 26 / 8 | 26 / 8 | 26 / 8 |
+| default exit | 0 | 0 | 0 |
+| `--assume-distinct-names` exit | 0 | 0 | 6 |
+
+Exiting 0 on 4.5.11 and 5.1.2 under the falsifier is correct by design.
+The naive assumption holds there for this modified cube, so there is
+nothing to catch. The falsifier exists to fail where the assumption
+broke.
+
+## API reference
+
+- [`Object.evaluated_get`](https://docs.blender.org/api/current/bpy.types.Object.html#bpy.types.Object.evaluated_get)
+  ([4.5 LTS](https://docs.blender.org/api/4.5/bpy.types.Object.html#bpy.types.Object.evaluated_get))
+- [`Object.to_mesh`](https://docs.blender.org/api/current/bpy.types.Object.html#bpy.types.Object.to_mesh)
+  and [`Object.to_mesh_clear`](https://docs.blender.org/api/current/bpy.types.Object.html#bpy.types.Object.to_mesh_clear)
+- [`ID.is_evaluated`](https://docs.blender.org/api/current/bpy.types.ID.html#bpy.types.ID.is_evaluated),
+  [`ID.original`](https://docs.blender.org/api/current/bpy.types.ID.html#bpy.types.ID.original)
+
 ## Run
 
 ```bash
diff --git a/examples/gallery.json b/examples/gallery.json
index fa5b2a2a..379297d1 100644
--- a/examples/gallery.json
+++ b/examples/gallery.json
@@ -34,7 +34,7 @@
       "name": "gn-sdf-remesh",
       "dir": "examples/gn-sdf-remesh",
       "teaches": "A Geometry Nodes SDF remesh (MeshToSDFGrid → GridToMesh at the SDF zero-level), with a Set Material node carrying the material through the remesh.",
-      "alt": "A glossy red torus with visibly blocky voxel faceting from the SDF remesh.",
+      "alt": "Two red tori side by side under pale edge cages: the source with even ring topology, and its SDF remesh covered in a dense irregular voxel grid.",
       "witnessesFix": "An SDF grid is meshed with Grid to Mesh, not Volume to Mesh; GN geometry needs Set Material or it renders untextured.",
       "hero": "docs/gallery/assets/gn-sdf-remesh-hero.webp",
       "preview": "examples/gn-sdf-remesh/preview.webp",
diff --git a/examples/gn-sdf-remesh/gn_sdf_remesh.py b/examples/gn-sdf-remesh/gn_sdf_remesh.py
index 627b0b9f..2a8a1a84 100644
--- a/examples/gn-sdf-remesh/gn_sdf_remesh.py
+++ b/examples/gn-sdf-remesh/gn_sdf_remesh.py
@@ -73,10 +73,56 @@ def render_still(obj, path, engine):
     wall.rotation_euler = (1.5708, 0, 0); bpy.context.collection.objects.link(wall)
     w = bpy.data.worlds.new("W"); w.use_nodes = True
     w.node_tree.nodes["Background"].inputs[0].default_value = (0.02, 0.021, 0.025, 1); sc.world = w
-    aim = bpy.data.objects.new("Aim", None); aim.location = (0, 0, 0.5); bpy.context.collection.objects.link(aim)
-    # off-axis and low: the remesh facets are the API evidence, and they only
-    # read when a raking key skims them from the side
-    cam = bpy.data.objects.new("cam", bpy.data.cameras.new("cam")); cam.location = (2.6, -5.2, 1.5)
+    # Input beside output. Alone, the remeshed torus read as a glossy inner
+    # tube with blotchy highlights: nothing said "remeshed". The source torus
+    # (a modifier-free copy of the same datablock) on the left and the SDF
+    # result on the right, each under a cage of its own edges, show the
+    # thing the check measures: UV-ring topology in, voxel-grid topology
+    # out. Render-path scaffolding only; the check ran before this.
+    obj.location.x = 1.85
+    src = bpy.data.objects.new("SourceTorus", obj.data.copy())
+    src.location = (-1.85, obj.location.y, obj.location.z)
+    bpy.context.collection.objects.link(src)
+    # build() centres the torus at z=0.55 with a 0.5 minor radius, so both
+    # hovered 5 cm over the floor. Ground each on its own measured bottom:
+    # the SDF surface is not exactly the source surface.
+    dg0 = bpy.context.evaluated_depsgraph_get()
+    em = obj.evaluated_get(dg0).to_mesh()
+    obj.location.z -= obj.location.z + min(v.co.z for v in em.vertices)
+    obj.evaluated_get(dg0).to_mesh_clear()
+    src.location.z = -min(v.co.z for v in src.data.vertices)
+    cage_mat = bpy.data.materials.new("Cage"); cage_mat.use_nodes = True
+    cb = cage_mat.node_tree.nodes.get('Principled BSDF')
+    cb.inputs['Base Color'].default_value = (0.92, 0.82, 0.62, 1)
+    cb.inputs['Roughness'].default_value = 0.4
+    cages = []
+    dg = bpy.context.evaluated_depsgraph_get()
+    for host, remeshed in ((src, False), (obj, True)):
+        # The remeshed cage is the evaluated result frozen into a plain mesh:
+        # a live copy of the tree would re-apply its Set Material and paint
+        # the cage crimson.
+        data = (bpy.data.meshes.new_from_object(obj.evaluated_get(dg))
+                if remeshed else obj.data.copy())
+        cage = bpy.data.objects.new(host.name + "Cage", data)
+        cage.data.materials.clear(); cage.data.materials.append(cage_mat)
+        for poly in cage.data.polygons:
+            poly.material_index = 0
+        cage.location = host.location
+        wire = cage.modifiers.new("cage", 'WIREFRAME')
+        wire.thickness = 0.012; wire.offset = 1.0; wire.use_even_offset = True
+        wire.material_offset = 0
+        bpy.context.collection.objects.link(cage)
+        cages.append(cage)
+    # Softer than 0.16: at that gloss every voxel facet threw its own hard
+    # glint and the highlight broke into blocks that read as artifacts.
+    for m in obj.data.materials:
+        if m is not None and m.node_tree is not None:
+            bsdf = m.node_tree.nodes.get('Principled BSDF')
+            if bsdf is not None:
+                bsdf.inputs['Roughness'].default_value = 0.32
+    aim = bpy.data.objects.new("Aim", None); aim.location = (0, 0, 0.45); bpy.context.collection.objects.link(aim)
+    # Raised so both donut holes read, and pulled back to hold the pair.
+    cam = bpy.data.objects.new("cam", bpy.data.cameras.new("cam")); cam.location = (1.5, -10.8, 5.5)
     bpy.context.collection.objects.link(cam); sc.camera = cam
     c = cam.constraints.new('TRACK_TO'); c.target = aim; c.track_axis = 'TRACK_NEGATIVE_Z'; c.up_axis = 'UP_Y'
     # low raking warm key so every facet catches a distinct glint, faint cool
diff --git a/examples/gn-sdf-remesh/preview.webp b/examples/gn-sdf-remesh/preview.webp
index f0289ece..9739e225 100644
Binary files a/examples/gn-sdf-remesh/preview.webp and b/examples/gn-sdf-remesh/preview.webp differ
diff --git a/showcase/README.md b/showcase/README.md
index 9236857a..e9bcdab8 100644
--- a/showcase/README.md
+++ b/showcase/README.md
@@ -52,6 +52,8 @@ entry in `showcase/gallery.json`, and a rendered still.
   `--round-haft` turns an oval section round (exit 19).
   `--float-nails` lifts nail heads off their strap (exit 18).
   `--short-mortar` stops every mortar joint shy of its stones (exit 18).
+  `--open-ends` restores open U-band ends so the water is not contained
+  (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:
@@ -339,6 +341,22 @@ entry in `showcase/gallery.json`, and a rendered still.
   course and every downstream stone budget measures the wrong
   neighbour. Add mortar after the chamfer pass, unchamfered: a 6 mm
   chamfer on a 10 mm bed eats it.
+- **A vessel holds its contents (exit 18).** A trough, tub, barrel or
+  bucket that shows a liquid must close every side of it. Touching the
+  hull is not holding: `water-trough` passed a water-to-hull gap budget
+  for a whole release with open U-band ends and the water's flat end face
+  on show. Assert containment by casting rays outward from across each
+  exposed face of the contents — perimeter **and** interior points, since
+  a rim band covers the perimeter only — and require every ray to hit the
+  vessel within a named reach. `--open-ends` is the falsifier.
+- **Keep a falsifier's envelope still.** A falsifier that moves the
+  support the piece grounds on re-grounds the whole piece and moves the
+  AABB with it. `water-trough`'s `--short-legs` lifted the shoes; the
+  piece re-grounded on the legs and shrank 10 mm against a 10 mm
+  tolerance, so a 1.5 mm model change tipped it from exit 16 to exit 8.
+  Make the falsifier move only what its budget measures — the shoes
+  float, the legs stretch to the floor — and check its AABB delta against
+  the tolerance, not just its exit code.
 - **Stone is not noise stretched over a block.** A noise-driven colour
   mix sampled so its features streak read as wood grain on
   `stone-archway` at hero scale. Stone wants isotropic object-space
diff --git a/showcase/gallery.json b/showcase/gallery.json
index 402aebeb..24e5c2be 100644
--- a/showcase/gallery.json
+++ b/showcase/gallery.json
@@ -195,7 +195,7 @@
       "name": "water-trough",
       "dir": "showcase/water-trough",
       "teaches": "A procedural watertight water trough through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.",
-      "alt": "A curved wooden water trough on crossed trestle legs, filled with dark green water.",
+      "alt": "A staved wooden water trough with solid half-round end boards on crossed trestle legs, half full of dark water.",
       "witnessesFix": "Recomputed: 3700 tris, three materials with 1674 wood, 156 metal and 29 water faces, UVs in 0..1 with zero AABB overlap, outer AABB 1.093×0.552×0.504 m, zmin 0, four shoes planted, U end-cap rim span 5 mm, strap BVH gap 0, water-hull gap 2.6 mm, hull 1.045×0.466 m, LOD ratios in band, convex collider 64 tris, non-empty glTF. --skip-decimate exits 9; --stray-vert 15; --lift-z/--short-legs 16; --box-ends 17; --float-strap 18; --narrow-hull 19.",
       "hero": "docs/gallery/assets/water-trough-hero.webp",
       "preview": "showcase/water-trough/preview.webp",
diff --git a/showcase/water-trough/README.md b/showcase/water-trough/README.md
index 41a27384..d1fe44ad 100644
--- a/showcase/water-trough/README.md
+++ b/showcase/water-trough/README.md
@@ -1,13 +1,14 @@
 # Water trough
 
 A showcase piece, not an example. Procedural staved water trough on a
-timber stand (watertight U-hull, U end-caps, contained water, iron
+timber stand (watertight U-hull, solid end boards, contained water, iron
 straps, trestle legs) then the shipped pipeline: unique-cell UVs, Cycles
 high-to-low normal bake, LOD chain, convex collider, Unity glTF export.
 
-The hull, ends, straps and water all sample the same YZ arc. End caps
-are U-boards the staves tenon into, not a bounding-box slab around the
-U. Straps sit at `STRAP_X`, offset from `LEG_X`, so the trestle does not
+The hull, ends, straps and water all sample the same YZ arc. Each end
+is a solid board whose bottom follows the hull's outer arc and whose top
+is level, and the staves tenon into it. It is neither a bounding-box slab
+around the U (`--box-ends`) nor an open U-band (`--open-ends`). Straps sit at `STRAP_X`, offset from `LEG_X`, so the trestle does not
 punch through the iron. Stretchers span the inner faces of the legs.
 `--round-band` is not used; `--float-strap` is the seat falsifier.
 
@@ -23,7 +24,7 @@ Hygiene combinatorics match `examples/mesh-hygiene-audit` (copied, not
 imported).
 
 Intended size: 1.08 m tray length, 0.44 m across the U, 0.50 m overall
-height; outer AABB 1.093 × 0.552 × 0.504 m.
+height; outer AABB 1.093 × 0.552 × 0.5055 m.
 
 ## Budgets
 
@@ -32,24 +33,26 @@ materials, UVs, evaluated LOD, collider, or export file.
 
 | Axis | Declared | Measured (4.5.11 / 5.1.2 / 5.2.1) |
 | --- | --- | --- |
-| Base triangles | 3300–4000 | 3700 / 3700 / 3700 |
+| Base triangles | 2800–3500 | 3124 / 3124 / 3124 |
 | LOD1 ratio | 0.32–0.62 of base | 0.5000 / 0.5000 / 0.5000 |
 | LOD2 ratio | 0.10–0.35 of base | 0.2200 / 0.2200 / 0.2200 |
-| Materials | exactly 3 distinct; ≥24 wood, ≥24 metal, ≥6 water | 3 slots; 1674 / 156 / 29 |
+| Materials | exactly 3 distinct; ≥24 wood, ≥24 metal, ≥6 water | 3 slots; 1386 / 156 / 29 |
 | UVs | in `0..1`, AABB overlap ≤ 1e-5 | in range, overlap 0 |
-| Outer AABB | (1.093, 0.552, 0.504) m ± 0.01 | (1.0932, 0.5520, 0.5040), zmin 0 |
+| Outer AABB | (1.093, 0.552, 0.5055) m ± 0.01 | (1.0932, 0.5520, 0.5055), zmin 0 |
 | Collider tris | ≤ 80 | 64 |
-| Export | written, size > 0 | 268840 / 268840 / 268824 bytes |
+| Export | written, size > 0 | 228520 / 228520 / 228504 bytes |
 
-Base triangles rose from **2484 to 3700** in the quality pass: box end
-slabs and a single extruded U became ten jittered staves, U end-caps,
+Base triangles rose from **2484 to 3700** in the first quality pass: box
+end slabs and a single extruded U became ten jittered staves, U end-caps,
 continuous straps offset from the legs, and stretchers that meet the
-inner faces.
+inner faces. The second pass took them to **3124**: the open U-band ends
+became solid end boards, which close the section with fewer faces.
 
 DECIMATE COLLAPSE triangle counts are **not** identical across series —
 the gate is a ratio band, not an exact count. Bake pixels are
 stochastic; the gate is `has_data` plus operator `FINISHED`, not
-byte-identity. Stave-width jitter uses closed-form `sin(i)`, no RNG.
+byte-identity. Stave-width jitter uses closed-form `sin(i)`; plank tone is the only RNG,
+seeded (`TONE_SEED`).
 Export byte counts differ by 16 B on 5.2.1 (glTF serializer), not a
 gated axis.
 
@@ -79,10 +82,42 @@ Recomputed from the generated mesh, not asserted about the script.
 | End-cap rim Z-span | ≤ 0.080 m | 0.0050 |
 | Strap-to-hull BVH gap | ≤ 0.008 m | 0.00000 |
 | Water-to-hull BVH gap | ≤ 0.008 m | 0.00260 |
+| Water contained by the end boards | 0 misses over 66 outward rays | 0 of 66 |
+
+### Why the ends are solid boards
+
+The first pass made each end a U-shaped band the staves tenoned into.
+That closed the rim and nothing else: the water's own flat end face sat
+exposed where a board belongs, visible in the end orthos and the
+end-cap close-ups. Water in that trough would pour straight out, and
+with the ends open the piece read as a hammock or sling. The strap and
+water gap budgets passed throughout, because the water did touch the
+hull; nothing asked whether anything held it in at the ends.
+
+`containment_audit` asks. From each water end face it casts rays outward
+along X, from the face's perimeter vertices and from points drawn 50% and
+90% of the way in from the centroid, so the middle of the section is
+tested and not only the rim a band would cover. Every ray must hit
+timber within `1.5 × END_T`. `--open-ends` restores the U-bands: all 66
+rays miss, and the piece exits 18.
+
+### Surface
+
+Staves, boards and legs came out of one flat material, so every board was
+the same board. `paint_planks` writes a seeded `PlankTone` and each
+shell's own long axis as `GrainDir`, as face attributes. The wood shader
+stretches its grain along that axis. The water was a 0.08-roughness mirror
+that went near-white under the key. It is now a dark body with a
+facing-ratio sky tint toward grazing angles and a faint ripple bump. A
+light placed to reflect in the surface was tried first and rejected: it
+either mirrored as a white sheet or showed nothing, and its spill lifted
+the dark stage. The fill dropped from 68% to 50%, so the inner stave
+walls show above the waterline; at 68% the surface sat nearly flush with
+the rim and read as felt in a frame. Straps widened from 28 to 40 mm.
 
 ### Falsifiers
 
-Each violates one named budget. All seven were run on 4.5.11, 5.1.2 and
+Each violates one named budget. All eight were run on 4.5.11, 5.1.2 and
 5.2.1 and returned the same code on each.
 
 | Flag | Budget violated | Exit |
@@ -94,9 +129,14 @@ Each violates one named budget. All seven were run on 4.5.11, 5.1.2 and
 | `--box-ends` | end-cap rim span | 17 |
 | `--float-strap` | strap-to-hull gap | 18 |
 | `--narrow-hull` | hull plan vs stated size | 19 |
+| `--open-ends` | water contained by the end boards (restores the open U-band ends) | 18 |
 
-`--short-legs` lifts the shoes only, so AABB `zmin` stays 0 (the legs
-still plant) and the named-support gate is what fires.
+`--short-legs` lifts the shoes and stretches each leg's foot down to the
+floor, so AABB `zmin` stays 0 (the legs still plant) and the
+named-support gate is what fires. Lifting the shoes alone used to let the
+whole piece re-ground on the legs. That shrank the AABB by ~10 mm, 0.4 mm
+inside the bounding-box tolerance, and a 1.5 mm model change in this pass
+tipped it to exit 8. With the feet stretched, the envelope moves 1.6 mm.
 
 ## Run
 
@@ -109,6 +149,7 @@ blender --background --python water_trough.py -- --short-legs
 blender --background --python water_trough.py -- --box-ends
 blender --background --python water_trough.py -- --float-strap
 blender --background --python water_trough.py -- --narrow-hull
+blender --background --python water_trough.py -- --open-ends
 blender --background --python water_trough.py -- --output trough.png
 ```
 
@@ -140,5 +181,5 @@ hygiene and joint-fit family.
 | 15 | Mesh hygiene: loose, non-manifold, zero-area, doubles, n-gons, z-fight |
 | 16 | Not grounded: bounding box `zmin` off 0, or a named shoe floats |
 | 17 | Joint fit: end-cap U-rim span (`--box-ends`) |
-| 18 | Seat: strap or water BVH gap (`--float-strap`) |
+| 18 | Seat: strap or water BVH gap (`--float-strap`), or water not contained by the end boards (`--open-ends`) |
 | 19 | Hull length or width off the stated real-world size (`--narrow-hull`) |
diff --git a/showcase/water-trough/preview.webp b/showcase/water-trough/preview.webp
index ad6c9f65..39ada843 100644
Binary files a/showcase/water-trough/preview.webp and b/showcase/water-trough/preview.webp differ
diff --git a/showcase/water-trough/water_trough.py b/showcase/water-trough/water_trough.py
index 510ca6fc..7da70d42 100644
--- a/showcase/water-trough/water_trough.py
+++ b/showcase/water-trough/water_trough.py
@@ -1,24 +1,26 @@
 """Game-ready wooden water trough — a showcase piece, not an example.
 
 Asserts budget conformance of a procedural staved trough on a timber
-stand (U-staves and U end-caps from one radius function, contained
+stand (U-staves and solid end boards from one radius function, contained
 water, iron straps lofted on that same host, trestle legs) after
 composing shipped pipeline pieces: bmesh construction, UVs, three
 materials, high-to-low normal bake, LOD chain, convex collider, Unity
 glTF export.
 
-The hull, ends, straps and water all sample the same YZ arc. End caps
-are U-boards the staves tenon into, not a bounding-box slab around the
-U. Legs run from a hull-outer station to a shoe at Z=0.
+The hull, ends, straps and water all sample the same YZ arc. Each end
+is a solid board on the hull's outer arc that the staves tenon into:
+not a bounding-box slab, not an open U-band. Legs run from a hull-outer station to a shoe at Z=0.
 
 Budgets are declared below and recomputed from the generated result.
 They are not API-contract witnesses. Each falsifier violates one named
 budget: ``--skip-decimate`` the LOD-ratio band, ``--stray-vert`` mesh
 hygiene, ``--lift-z`` grounded zmin, ``--short-legs`` named shoe
 supports, ``--box-ends`` end-cap U-fit, ``--float-strap`` strap seat,
-``--narrow-hull`` hull real-world size.
+``--narrow-hull`` hull real-world size, ``--open-ends`` water
+containment.
 
-No RNG. Stave seams use closed-form ``sin(i)``. DECIMATE COLLAPSE
+Stave seams use closed-form ``sin(i)``; the only RNG is plank tone,
+seeded with ``TONE_SEED``. DECIMATE COLLAPSE
 triangle counts are not byte-identical across Blender versions — the LOD
 gate is a ratio band, not an exact count.
 
@@ -29,6 +31,7 @@
 import argparse
 import math
 import os
+import random
 import sys
 import tempfile
 import traceback
@@ -53,7 +56,7 @@
 END_T = 0.044
 END_OVERHANG = 0.010
 STAVE_GAP = 0.008
-STRAP_W = 0.028
+STRAP_W = 0.040
 STRAP_T = 0.008
 STRAP_BITE = 0.008
 SHOE_H = 0.028
@@ -66,15 +69,17 @@
 STRETCHER_T = 0.028
 LEG_W = 0.048
 WATER_GAP = 0.004
-WATER_FILL = 0.68
+# Half full: at 0.68 the surface sat nearly flush with the rim and hid the
+# inner stave walls, so nothing said vessel.
+WATER_FILL = 0.50
 
 BBOX_TOL = 0.01
-OUTER_SIZE = (1.093, 0.552, 0.504)
+OUTER_SIZE = (1.093, 0.552, 0.5055)
 HULL_SIZE = (1.08, 0.44)
 HULL_SIZE_TOL = (0.08, 0.08)
 NARROW_HULL_R = 0.12
-BASE_TRIS_MIN = 3300
-BASE_TRIS_MAX = 4000
+BASE_TRIS_MIN = 2800
+BASE_TRIS_MAX = 3500
 LOD1_RATIO_MIN = 0.32
 LOD1_RATIO_MAX = 0.62
 LOD2_RATIO_MIN = 0.10
@@ -108,6 +113,15 @@
 METAL_IDX = 1
 WATER_IDX = 2
 
+# Water containment: rays cast outward along X from points across each end
+# face of the water must hit an end board within this reach. The ends used
+# to be open U-bands; the water's own end face showed where a board belongs
+# and nothing held it in.
+CONTAIN_REACH = END_T * 1.5
+CONTAIN_FRACS = (0.0, 0.5, 0.9)
+PLANK_TONE_JITTER = 0.28
+TONE_SEED = 61
+
 
 def eevee_engine_id():
     return "BLENDER_EEVEE" if bpy.app.version >= (5, 0, 0) else "BLENDER_EEVEE_NEXT"
@@ -227,6 +241,38 @@ def ring(x):
     return r0 + r1
 
 
+def add_end_board(bm, x0, x1, r_arc, z_top, n_seg, zc, a_span, mat_idx):
+    """A solid end board: the hull's own outer arc below, a level top above.
+
+    The profile is closed with vertical strips from each arc point up to
+    ``z_top``, so every face is a quad and there is no n-gon to fan. The
+    bottom follows the hull arc, which is what separates it from the
+    bounding-box slab ``--box-ends`` builds.
+    """
+    def ring(x):
+        arc = []
+        top = []
+        for i in range(n_seg + 1):
+            a = -a_span + 2.0 * a_span * i / n_seg
+            p = _arc_point(a, r_arc, x, zc)
+            arc.append(bm.verts.new(p))
+            top.append(bm.verts.new((x, p.y, z_top)))
+        return arc, top
+
+    arc0, top0 = ring(x0)
+    arc1, top1 = ring(x1)
+    verts = arc0 + top0 + arc1 + top1
+    for i in range(n_seg):
+        j = i + 1
+        _face(bm, (arc0[i], top0[i], top0[j], arc0[j]), mat_idx)
+        _face(bm, (arc1[j], top1[j], top1[i], arc1[i]), mat_idx)
+        _face(bm, (arc0[j], arc1[j], arc1[i], arc0[i]), mat_idx)
+        _face(bm, (top0[i], top1[i], top1[j], top0[j]), mat_idx)
+    _face(bm, (arc0[0], arc1[0], top1[0], top0[0]), mat_idx)
+    _face(bm, (arc0[n_seg], top0[n_seg], top1[n_seg], arc1[n_seg]), mat_idx)
+    return verts
+
+
 def add_box_end(bm, x_mid, radius, zc, a_span, thick, mat_idx):
     y_span = 2.0 * radius * math.sin(a_span)
     z_lo = zc - radius
@@ -317,6 +363,7 @@ def build_trough_mesh(
     float_strap=False,
     short_legs=False,
     narrow_hull=False,
+    open_ends=False,
 ):
     bm = bmesh.new()
     try:
@@ -345,19 +392,26 @@ def build_trough_mesh(
             )
             a = a1 + STAVE_GAP
 
-        if not box_ends:
-            r_cap_in = r_in - 0.006
-            r_cap_out = r_out + END_OVERHANG
-            wood.extend(
-                add_u_shell(
-                    bm, x_cap_l0, x_cap_l1, r_cap_in, r_cap_out, N_STAVES, zc, A_SPAN, WOOD_IDX
+        r_cap_in = r_in - 0.006
+        r_cap_out = r_out + END_OVERHANG
+        if open_ends:
+            # The pre-pass end: a U-band the staves tenon into, open in the
+            # middle. --open-ends restores it as the containment falsifier.
+            for xa, xb in ((x_cap_l0, x_cap_l1), (x_cap_r0, x_cap_r1)):
+                wood.extend(
+                    add_u_shell(
+                        bm, xa, xb, r_cap_in, r_cap_out, N_STAVES, zc, A_SPAN, WOOD_IDX
+                    )
                 )
-            )
-            wood.extend(
-                add_u_shell(
-                    bm, x_cap_r0, x_cap_r1, r_cap_in, r_cap_out, N_STAVES, zc, A_SPAN, WOOD_IDX
+        elif not box_ends:
+            # Top sits at the band's inner rim, 6 mm proud of the staves.
+            z_top = zc - r_cap_in * math.cos(A_SPAN)
+            for xa, xb in ((x_cap_l0, x_cap_l1), (x_cap_r0, x_cap_r1)):
+                wood.extend(
+                    add_end_board(
+                        bm, xa, xb, r_cap_out, z_top, N_STAVES, zc, A_SPAN, WOOD_IDX
+                    )
                 )
-            )
 
         top_z = hull_z_at_y(LEG_TOP_Y, r_out, zc)
         bot_z = SHOE_H * 0.55
@@ -370,7 +424,21 @@ def build_trough_mesh(
                 bot_pt = Vector((sx, ysign * LEG_BOT_Y, bot_z))
                 direction = (top_pt - bot_pt).normalized()
                 top_pt = top_pt + direction * (STAVE_T * 0.35)
-                wood.extend(add_oriented_box(bm, top_pt, bot_pt, (LEG_W, 0.034), WOOD_IDX))
+                leg = add_oriented_box(bm, top_pt, bot_pt, (LEG_W, 0.034), WOOD_IDX)
+                if short_legs:
+                    # The legs, not the shoes, must plant: stretch each leg's
+                    # foot down to the floor so the lifted shoes float while
+                    # the piece keeps the same floor and envelope. Lifting the
+                    # shoes alone let the whole piece re-ground on the legs,
+                    # shrinking the AABB ~10 mm; that sat 0.4 mm inside the
+                    # bbox tolerance and tipped to exit 8 on a 1.5 mm model
+                    # change.
+                    zmid = 0.5 * (top_pt.z + bot_pt.z)
+                    foot = [v for v in leg if v.co.z < zmid]
+                    drop = min(v.co.z for v in foot)
+                    for v in foot:
+                        v.co.z -= drop
+                wood.extend(leg)
             t_st = (STRETCHER_Z - bot_z) / max(top_z - bot_z, 1e-6)
             y_leg = LEG_BOT_Y + t_st * (LEG_TOP_Y - LEG_BOT_Y)
             # Inner face of the diagonal leg, not through its volume.
@@ -394,7 +462,12 @@ def build_trough_mesh(
         )
 
         if bevel_offset > 0.0:
-            edges = list({e for v in wood for e in v.link_edges})
+            # Flat edges (the strip seams across an end board's face) are
+            # not corners; chamfering one creases a flat face.
+            edges = [
+                e for e in {e for v in wood for e in v.link_edges}
+                if not (len(e.link_faces) == 2 and e.calc_face_angle(0.0) < 1e-4)
+            ]
             ret = bmesh.ops.bevel(
                 bm,
                 geom=edges,
@@ -479,11 +552,58 @@ def build_trough_mesh(
             poly.use_smooth = False
     finally:
         bm.free()
+    paint_planks(me)
     out = bpy.data.objects.new(name, me)
     bpy.context.collection.objects.link(out)
     return out
 
 
+def _long_axis(pts):
+    """Principal axis of a point set, by power iteration on its covariance."""
+    n = len(pts)
+    c = sum(pts, Vector()) / n
+    cov = [[0.0] * 3 for _ in range(3)]
+    for p in pts:
+        d = p - c
+        for i in range(3):
+            for j in range(3):
+                cov[i][j] += d[i] * d[j]
+    v = Vector((1.0, 0.3, 0.1))
+    for _ in range(30):
+        w = Vector([sum(cov[i][j] * v[j] for j in range(3)) for i in range(3)])
+        if w.length < 1e-12:
+            break
+        v = w.normalized()
+    return v
+
+
+def paint_planks(me):
+    """Per-shell tone and grain direction, as face attributes.
+
+    Staves, end boards and legs came out of one flat material, so every
+    board was the same board. The wood shader stretches its grain along
+    ``GrainDir`` (each shell's own long axis) and shades by ``PlankTone``.
+    """
+    tone = [0.5] * len(me.polygons)
+    grain = [(1.0, 0.0, 0.0)] * len(me.polygons)
+    owner = {}
+    rng = random.Random(TONE_SEED)
+    for g in shells(me):
+        pts = [me.vertices[i].co.copy() for i in g]
+        d = _long_axis(pts) if len(pts) > 2 else Vector((1.0, 0.0, 0.0))
+        t = 0.5 + rng.uniform(-PLANK_TONE_JITTER, PLANK_TONE_JITTER)
+        for i in g:
+            owner[i] = (t, tuple(d))
+    for poly in me.polygons:
+        t, d = owner[poly.vertices[0]]
+        tone[poly.index] = t
+        grain[poly.index] = d
+    a = me.attributes.new("PlankTone", "FLOAT", "FACE")
+    a.data.foreach_set("value", tone)
+    b = me.attributes.new("GrainDir", "FLOAT_VECTOR", "FACE")
+    b.data.foreach_set("vector", [c for v in grain for c in v])
+
+
 def principled(name, color, metallic, roughness, roughness_var=0.0):
     mat = bpy.data.materials.new(name)
     mat.use_nodes = True
@@ -507,6 +627,119 @@ def principled(name, color, metallic, roughness, roughness_var=0.0):
     return mat
 
 
+def _sock(sockets, identifier):
+    """A Mix-node socket by identifier; its A/B/Result names repeat per type."""
+    return next(sk for sk in sockets if sk.identifier == identifier)
+
+
+def wood_material(name):
+    """Grain along each board (``GrainDir``), tone per board (``PlankTone``)."""
+    mat = bpy.data.materials.new(name)
+    mat.use_nodes = True
+    nt = mat.node_tree
+    bsdf = nt.nodes["Principled BSDF"]
+    coord = nt.nodes.new("ShaderNodeTexCoord")
+    gdir = nt.nodes.new("ShaderNodeAttribute")
+    gdir.attribute_name = "GrainDir"
+    tone = nt.nodes.new("ShaderNodeAttribute")
+    tone.attribute_name = "PlankTone"
+    dot = nt.nodes.new("ShaderNodeVectorMath")
+    dot.operation = "DOT_PRODUCT"
+    nt.links.new(coord.outputs["Object"], dot.inputs[0])
+    nt.links.new(gdir.outputs["Vector"], dot.inputs[1])
+    squash = nt.nodes.new("ShaderNodeMath")
+    squash.operation = "MULTIPLY"
+    squash.inputs[1].default_value = 0.94
+    nt.links.new(dot.outputs["Value"], squash.inputs[0])
+    along = nt.nodes.new("ShaderNodeVectorMath")
+    along.operation = "SCALE"
+    nt.links.new(gdir.outputs["Vector"], along.inputs[0])
+    nt.links.new(squash.outputs["Value"], along.inputs["Scale"])
+    grain_co = nt.nodes.new("ShaderNodeVectorMath")
+    grain_co.operation = "SUBTRACT"
+    nt.links.new(coord.outputs["Object"], grain_co.inputs[0])
+    nt.links.new(along.outputs["Vector"], grain_co.inputs[1])
+    shift = nt.nodes.new("ShaderNodeVectorMath")
+    shift.operation = "ADD"
+    nt.links.new(grain_co.outputs["Vector"], shift.inputs[0])
+    nt.links.new(tone.outputs["Fac"], shift.inputs[1])
+    noise = nt.nodes.new("ShaderNodeTexNoise")
+    noise.inputs["Scale"].default_value = 30.0
+    noise.inputs["Detail"].default_value = 6.0
+    noise.inputs["Roughness"].default_value = 0.62
+    nt.links.new(shift.outputs["Vector"], noise.inputs["Vector"])
+    ramp = nt.nodes.new("ShaderNodeValToRGB")
+    ramp.color_ramp.elements[0].position = 0.30
+    ramp.color_ramp.elements[0].color = (0.13, 0.062, 0.024, 1.0)
+    ramp.color_ramp.elements[1].position = 0.72
+    ramp.color_ramp.elements[1].color = (0.40, 0.21, 0.085, 1.0)
+    nt.links.new(noise.outputs["Fac"], ramp.inputs["Fac"])
+    gain = nt.nodes.new("ShaderNodeMath")
+    gain.operation = "MULTIPLY_ADD"
+    gain.inputs[1].default_value = 1.1
+    gain.inputs[2].default_value = 0.45
+    nt.links.new(tone.outputs["Fac"], gain.inputs[0])
+    mix = nt.nodes.new("ShaderNodeMix")
+    mix.data_type = "RGBA"
+    mix.blend_type = "MULTIPLY"
+    _sock(mix.inputs, "Factor_Float").default_value = 1.0
+    nt.links.new(ramp.outputs["Color"], _sock(mix.inputs, "A_Color"))
+    nt.links.new(gain.outputs["Value"], _sock(mix.inputs, "B_Color"))
+    nt.links.new(_sock(mix.outputs, "Result_Color"), bsdf.inputs["Base Color"])
+    rough = nt.nodes.new("ShaderNodeMapRange")
+    rough.inputs["To Min"].default_value = 0.72
+    rough.inputs["To Max"].default_value = 0.52
+    nt.links.new(noise.outputs["Fac"], rough.inputs["Value"])
+    nt.links.new(rough.outputs["Result"], bsdf.inputs["Roughness"])
+    return mat
+
+
+def water_material(name):
+    """Dark, clear-reading water with a faint ripple.
+
+    The old flat 0.08-roughness teal was a mirror: under the key it went
+    near-white and, with open ends, read as a stretched fabric sling. A
+    darker body and a small noise bump break the reflection into a surface.
+    """
+    mat = bpy.data.materials.new(name)
+    mat.use_nodes = True
+    nt = mat.node_tree
+    bsdf = nt.nodes["Principled BSDF"]
+    bsdf.inputs["Roughness"].default_value = 0.06
+    bsdf.inputs["IOR"].default_value = 1.33
+    # Deep body where the view looks straight down, a pale sky tint toward
+    # grazing angles. A light placed to reflect in the surface was
+    # all-or-nothing (white mirror or nothing) and flooded the dark stage;
+    # a facing-ratio tint gives the sheen without touching the lighting.
+    facing = nt.nodes.new("ShaderNodeLayerWeight")
+    facing.inputs["Blend"].default_value = 0.55
+    tint = nt.nodes.new("ShaderNodeMix")
+    tint.data_type = "RGBA"
+    _sock(tint.inputs, "A_Color").default_value = (0.010, 0.040, 0.046, 1.0)
+    _sock(tint.inputs, "B_Color").default_value = (0.20, 0.27, 0.29, 1.0)
+    nt.links.new(facing.outputs["Facing"], _sock(tint.inputs, "Factor_Float"))
+    nt.links.new(_sock(tint.outputs, "Result_Color"), bsdf.inputs["Base Color"])
+    coord = nt.nodes.new("ShaderNodeTexCoord")
+    noise = nt.nodes.new("ShaderNodeTexNoise")
+    noise.inputs["Scale"].default_value = 22.0
+    noise.inputs["Detail"].default_value = 3.0
+    nt.links.new(coord.outputs["Object"], noise.inputs["Vector"])
+    bump = nt.nodes.new("ShaderNodeBump")
+    bump.inputs["Strength"].default_value = 0.08
+    bump.inputs["Distance"].default_value = 0.004
+    nt.links.new(noise.outputs["Fac"], bump.inputs["Height"])
+    nt.links.new(bump.outputs["Normal"], bsdf.inputs["Normal"])
+    return mat
+
+
+def trough_materials():
+    """(wood, iron, water): shared by the check, the render and inspection."""
+    wood = wood_material("TroughWood")
+    metal = principled("TroughIron", (0.16, 0.155, 0.15, 1.0), 0.85, 0.42, roughness_var=0.10)
+    water = water_material("TroughWater")
+    return wood, metal, water
+
+
 def assign_slots(obj, wood, metal, water):
     mats = obj.data.materials
     wanted = (wood, metal, water)
@@ -779,6 +1012,43 @@ def joint_audit(me):
     }
 
 
+def containment_audit(me):
+    """Rays outward along X from across each water end face must hit a board.
+
+    Samples each end face at its perimeter vertices and at points drawn
+    toward the face centroid (CONTAIN_FRACS), so the middle of the section
+    is tested, not only the rim a U-band would cover. A miss is water with
+    nothing holding it in.
+    """
+    water_v = {i for p in me.polygons if p.material_index == WATER_IDX for i in p.vertices}
+    if not water_v:
+        return {"rays": 0, "misses": 1}
+    bm = bmesh.new()
+    try:
+        bm.from_mesh(me)
+        drop = [f for f in bm.faces if f.material_index != WOOD_IDX]
+        bmesh.ops.delete(bm, geom=drop, context="FACES")
+        tree = BVHTree.FromBMesh(bm)
+    finally:
+        bm.free()
+    pts = [me.vertices[i].co for i in water_v]
+    xmin = min(p.x for p in pts)
+    xmax = max(p.x for p in pts)
+    rays = misses = 0
+    for x_end, out in ((xmin, -1.0), (xmax, 1.0)):
+        face = [p for p in pts if abs(p.x - x_end) < 1e-5]
+        c = sum(face, Vector()) / len(face)
+        for p in face:
+            for t in CONTAIN_FRACS:
+                q = c + (p - c) * t
+                origin = Vector((x_end - out * 1e-4, q.y, q.z))
+                hit = tree.ray_cast(origin, Vector((out, 0.0, 0.0)), CONTAIN_REACH)
+                rays += 1
+                if hit[0] is None:
+                    misses += 1
+    return {"rays": rays, "misses": misses}
+
+
 def add_stray_vert(me):
     bm = bmesh.new()
     try:
@@ -884,6 +1154,7 @@ def check(
     float_strap=False,
     short_legs=False,
     narrow_hull=False,
+    open_ends=False,
 ):
     bpy.ops.wm.read_factory_settings(use_empty=True)
     low = build_trough_mesh(
@@ -894,6 +1165,7 @@ def check(
         float_strap=float_strap,
         short_legs=short_legs,
         narrow_hull=narrow_hull,
+        open_ends=open_ends,
     )
     high = build_trough_mesh(
         "TroughHigh",
@@ -903,10 +1175,9 @@ def check(
         float_strap=float_strap,
         short_legs=short_legs,
         narrow_hull=narrow_hull,
+        open_ends=open_ends,
     )
-    wood = principled("TroughWood", (0.40, 0.22, 0.08, 1.0), 0.0, 0.58, roughness_var=0.10)
-    metal = principled("TroughIron", (0.10, 0.105, 0.12, 1.0), 1.0, 0.32, roughness_var=0.08)
-    water = principled("TroughWater", (0.06, 0.16, 0.18, 1.0), 0.0, 0.08)
+    wood, metal, water = trough_materials()
     assign_slots(low, wood, metal, water)
     assign_slots(high, wood, metal, water)
 
@@ -937,6 +1208,7 @@ def check(
     zf = zfight_pairs(low.data)
     sup = support_audit(low.data)
     jnt = joint_audit(low.data)
+    con = containment_audit(low.data)
 
     img, tex = setup_bake_image(low, wood)
     if img is None:
@@ -964,6 +1236,10 @@ def check(
         os.remove(export_path)
     export_unity(export_path, [low, collider])
     export_size = os.path.getsize(export_path) if os.path.isfile(export_path) else 0
+    # Blender points TMPDIR at its own temp preference, which on a portable
+    # build is the working directory, so the export must not outlive this.
+    if os.path.isfile(export_path):
+        os.remove(export_path)
 
     print(f"blender={tuple(bpy.app.version)} skip_decimate={skip_decimate}")
     print(
@@ -993,6 +1269,7 @@ def check(
         f"water_gap={jnt['water_gap']:.5f} hull_xy={jnt['hull_xy']} "
         f"ends={jnt['ends']} straps={jnt['straps']}"
     )
+    print(f"measured containment rays={con['rays']} misses={con['misses']}")
 
     if not (BASE_TRIS_MIN <= base_tris <= BASE_TRIS_MAX):
         return fail(
@@ -1108,6 +1385,13 @@ def check(
             f"water-hull gap {jnt['water_gap']:.5f}",
             18,
         ), None, None, None, None, None
+    if con["rays"] == 0 or con["misses"]:
+        return fail(
+            f"water not contained: {con['misses']} of {con['rays']} outward rays "
+            "from the water end faces hit no end board "
+            "(--open-ends is the designed fail)",
+            18,
+        ), None, None, None, None, None
     return 0, low, high, wood, tex, collider
 
 
@@ -1228,6 +1512,7 @@ def main():
     p.add_argument("--box-ends", action="store_true")
     p.add_argument("--float-strap", action="store_true")
     p.add_argument("--narrow-hull", action="store_true")
+    p.add_argument("--open-ends", action="store_true")
     args = p.parse_args(argv)
 
     code, low, _high, wood, tex, _col = check(
@@ -1238,6 +1523,7 @@ def main():
         float_strap=args.float_strap,
         short_legs=args.short_legs,
         narrow_hull=args.narrow_hull,
+        open_ends=args.open_ends,
     )
     if code:
         return code