diff --git a/README.md b/README.md
index 692088a..4275c99 100644
--- a/README.md
+++ b/README.md
@@ -677,10 +677,10 @@ with the Smooth-by-Angle modifier on 5.1.
 The mesh-cleanliness contract a prop pipeline relies on before engine ingest:
 no ngons, no loose vertices, every edge bordering exactly two faces, no
 zero-area faces, positive signed volume, and Euler `V − E + F == 2` for a
-closed solid (measured 24/44/22, volume 0.989248). Companion to
+closed solid (measured 66/136/72, volume 0.652001). Companion to
 [`collision-hull-proxy`](examples/collision-hull-proxy/) (hull watertightness)
 and [`bmesh-gear`](examples/bmesh-gear/) (parametric closed solids). Dual-panel
-still: DIRTY (injected boundary + loose vert) vs CLEAN.
+still: DIRTY through-hole + loose-vert bead vs CLEAN manifold (same brass).
 
 </td>
 </tr>
@@ -695,9 +695,10 @@ still: DIRTY (injected boundary + loose vert) vs CLEAN.
 The origin / scale-apply / MPI contract a prop pipeline relies on before
 engine ingest: data-API scale bake to exactly `(1,1,1)`, local bbox
 `min.z == 0` (origin at base), world AABB unchanged across the bake, and
-`matrix_parent_inverse` so a bolted accessory does not teleport. Extends
-[`parent-inverse-orrery`](examples/parent-inverse-orrery/) without retreading
-orbits. Dual-panel still: TRAP (bare parent) vs MPI KEEP.
+`matrix_parent_inverse` so a flanged conduit stays on its mount socket.
+Extends [`parent-inverse-orrery`](examples/parent-inverse-orrery/) without
+retreading orbits. Dual-panel still: TRAP (bare parent — empty socket +
+teleported flange) vs MPI KEEP.
 
 </td>
 </tr>
diff --git a/docs/gallery/assets/mesh-hygiene-audit-hero.webp b/docs/gallery/assets/mesh-hygiene-audit-hero.webp
index 3756513..a6f40da 100644
Binary files a/docs/gallery/assets/mesh-hygiene-audit-hero.webp and b/docs/gallery/assets/mesh-hygiene-audit-hero.webp differ
diff --git a/docs/gallery/assets/prop-origin-transform-hero.webp b/docs/gallery/assets/prop-origin-transform-hero.webp
index df0116d..e5a3680 100644
Binary files a/docs/gallery/assets/prop-origin-transform-hero.webp and b/docs/gallery/assets/prop-origin-transform-hero.webp differ
diff --git a/docs/gallery/contact-sheets/mesh-hygiene-audit-contact-sheet.webp b/docs/gallery/contact-sheets/mesh-hygiene-audit-contact-sheet.webp
index c680f01..a24b79b 100644
Binary files a/docs/gallery/contact-sheets/mesh-hygiene-audit-contact-sheet.webp and b/docs/gallery/contact-sheets/mesh-hygiene-audit-contact-sheet.webp differ
diff --git a/docs/gallery/contact-sheets/prop-origin-transform-contact-sheet.webp b/docs/gallery/contact-sheets/prop-origin-transform-contact-sheet.webp
index d32c754..527b06b 100644
Binary files a/docs/gallery/contact-sheets/prop-origin-transform-contact-sheet.webp and b/docs/gallery/contact-sheets/prop-origin-transform-contact-sheet.webp differ
diff --git a/docs/gallery/index.html b/docs/gallery/index.html
index 828b266..fe50ab4 100644
--- a/docs/gallery/index.html
+++ b/docs/gallery/index.html
@@ -589,23 +589,23 @@ <h2><a href="gp-lineart-contour/">gp-lineart-contour</a></h2>
       </article>
       <article class="card" data-tags="bmesh mesh game-pipeline">
         <a class="card-media" href="mesh-hygiene-audit/" aria-label="mesh-hygiene-audit example detail page">
-          <img src="assets/mesh-hygiene-audit-hero.webp" alt="mesh-hygiene-audit — Engine-ingest mesh hygiene as executable topology checks on a stepped street electrical pedestal (plinth, cabinet, drip cap)." loading="lazy" decoding="async" />
+          <img src="assets/mesh-hygiene-audit-hero.webp" alt="mesh-hygiene-audit — Engine-ingest mesh hygiene on an octagonal street valve: no ngons, no loose verts, manifold edges, no zero-area faces, positive signed volume, Euler V-E+F==2." loading="lazy" decoding="async" />
         </a>
         <div class="card-body">
           <h2><a href="mesh-hygiene-audit/">mesh-hygiene-audit</a></h2>
-          <p class="teaches">Engine-ingest mesh hygiene as executable topology checks on a stepped street electrical pedestal (plinth, cabinet, drip cap). Gates: no ngons, no loose verts, every edge borders exactly 2 faces, no zero-area faces (min_area printed), positive signed volume, Euler V-E+F==2 (24/44/22, volume 0.989248). Dual-panel dirty vs clean still marks defects.</p>
-          <p class="witnesses"><span class="tag">witnesses</span> AI pipelines that skip topology gates ship ngons, loose verts, open boundaries, inverted winding, or non-sphere Euler into engine ingest. Injecting one defect class at a time exits non-zero (ngon=3, loose=4, boundary=5, zero-area=6, flip=7); the clean solid recovers hygiene_ok on both 4.5.11 and 5.1.2.</p>
+          <p class="teaches">Engine-ingest mesh hygiene on an octagonal street valve: no ngons, no loose verts, manifold edges, no zero-area faces, positive signed volume, Euler V-E+F==2. Dual-panel still shows a through-hole and loose-vert bead derived from live mesh incidence — same brass on both so color alone cannot carry the proof.</p>
+          <p class="witnesses"><span class="tag">witnesses</span> Pipelines that skip topology gates ship open boundaries, loose verts, or non-sphere Euler into engine ingest. The still makes the boundary hole and loose vert readable; ngon / zero-area / full winding invert remain check-only.</p>
           <a class="card-link" href="mesh-hygiene-audit/">View example <span aria-hidden="true">&rarr;</span></a>
         </div>
       </article>
       <article class="card" data-tags="transform parenting game-pipeline">
         <a class="card-media" href="prop-origin-transform/" aria-label="prop-origin-transform example detail page">
-          <img src="assets/prop-origin-transform-hero.webp" alt="prop-origin-transform — Street pedestal origin-to-base-center + data-API scale apply + matrix_parent_inverse for a bolted accessory." loading="lazy" decoding="async" />
+          <img src="assets/prop-origin-transform-hero.webp" alt="prop-origin-transform — Street pedestal origin-to-base-center + data-API scale apply + matrix_parent_inverse for a flanged conduit accessory." loading="lazy" decoding="async" />
         </a>
         <div class="card-body">
           <h2><a href="prop-origin-transform/">prop-origin-transform</a></h2>
-          <p class="teaches">Street pedestal origin-to-base-center + data-API scale apply + matrix_parent_inverse for a bolted accessory. After bake: scale exactly (1,1,1), local min.z==0, world AABB delta 0. Bare parent jumps the accessory (~0.43 m); MPI restores world location (~3e-8). view_layer.update() before reading matrix_world.</p>
-          <p class="witnesses"><span class="tag">witnesses</span> AI code parents with child.parent = parent alone (accessory teleports), skips view_layer.update() before matrix_world, or leaves non-uniform scale / centered origin for engine ingest. Skipping apply, origin bake, or MPI each fails a closed-form gate.</p>
+          <p class="teaches">Street pedestal origin-to-base-center + data-API scale apply + matrix_parent_inverse for a flanged conduit accessory. After bake: scale (1,1,1), local min.z==0, world AABB unchanged. Bare parent jumps the accessory off an empty mount socket; MPI keeps it seated.</p>
+          <p class="witnesses"><span class="tag">witnesses</span> Bare child.parent = parent teleports accessories off their mounts; skipping view_layer.update() before matrix_world, or leaving non-uniform scale / centered origin, breaks engine ingest placement.</p>
           <a class="card-link" href="prop-origin-transform/">View example <span aria-hidden="true">&rarr;</span></a>
         </div>
       </article>
diff --git a/docs/gallery/mesh-hygiene-audit/index.html b/docs/gallery/mesh-hygiene-audit/index.html
index d9415b8..66b01d6 100644
--- a/docs/gallery/mesh-hygiene-audit/index.html
+++ b/docs/gallery/mesh-hygiene-audit/index.html
@@ -4,18 +4,18 @@
   <meta charset="utf-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1" />
   <title>mesh-hygiene-audit — Examples — Blender Developer Tools</title>
-  <meta name="description" content="Engine-ingest mesh hygiene as executable topology checks on a stepped street electrical pedestal (plinth, cabinet, drip cap). Gates: no ngons, no loose verts, every edge borders exactly 2 faces, no zero-area faces (min_area printed), positive signed volume, Euler V-E+F==2 (24/44/22, volume 0.989248). Dual-panel dirty vs clean still marks defects." />
+  <meta name="description" content="Engine-ingest mesh hygiene on an octagonal street valve: no ngons, no loose verts, manifold edges, no zero-area faces, positive signed volume, Euler V-E+F==2. Dual-panel still shows a through-hole and loose-vert bead derived from live mesh incidence — same brass on both so color alone cannot carry the proof." />
   <link rel="canonical" href="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/mesh-hygiene-audit/" />
   <link rel="icon" href="../../assets/favicon.svg" type="image/svg+xml" />
   <meta name="theme-color" content="#1a1b1e" />
   <meta property="og:type" content="website" />
   <meta property="og:title" content="mesh-hygiene-audit — Examples — Blender Developer Tools" />
-  <meta property="og:description" content="Engine-ingest mesh hygiene as executable topology checks on a stepped street electrical pedestal (plinth, cabinet, drip cap). Gates: no ngons, no loose verts, every edge borders exactly 2 faces, no zero-area faces (min_area printed), positive signed volume, Euler V-E+F==2 (24/44/22, volume 0.989248). Dual-panel dirty vs clean still marks defects." />
+  <meta property="og:description" content="Engine-ingest mesh hygiene on an octagonal street valve: no ngons, no loose verts, manifold edges, no zero-area faces, positive signed volume, Euler V-E+F==2. Dual-panel still shows a through-hole and loose-vert bead derived from live mesh incidence — same brass on both so color alone cannot carry the proof." />
   <meta property="og:url" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/mesh-hygiene-audit/" />
   <meta property="og:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/mesh-hygiene-audit-hero.webp" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="mesh-hygiene-audit — Examples — Blender Developer Tools" />
-  <meta name="twitter:description" content="Engine-ingest mesh hygiene as executable topology checks on a stepped street electrical pedestal (plinth, cabinet, drip cap). Gates: no ngons, no loose verts, every edge borders exactly 2 faces, no zero-area faces (min_area printed), positive signed volume, Euler V-E+F==2 (24/44/22, volume 0.989248). Dual-panel dirty vs clean still marks defects." />
+  <meta name="twitter:description" content="Engine-ingest mesh hygiene on an octagonal street valve: no ngons, no loose verts, manifold edges, no zero-area faces, positive signed volume, Euler V-E+F==2. Dual-panel still shows a through-hole and loose-vert bead derived from live mesh incidence — same brass on both so color alone cannot carry the proof." />
   <meta name="twitter:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/mesh-hygiene-audit-hero.webp" />
   <style>
     /* fonts are deployed by the landing build (docs/fonts/) */
@@ -170,35 +170,33 @@
   </div>
   <header class="hero">
     <h1>mesh-hygiene-audit</h1>
-    <p>Engine-ingest mesh hygiene as executable topology checks on a stepped street electrical pedestal (plinth, cabinet, drip cap). Gates: no ngons, no loose verts, every edge borders exactly 2 faces, no zero-area faces (min_area printed), positive signed volume, Euler V-E+F==2 (24/44/22, volume 0.989248). Dual-panel dirty vs clean still marks defects.</p>
+    <p>Engine-ingest mesh hygiene on an octagonal street valve: no ngons, no loose verts, manifold edges, no zero-area faces, positive signed volume, Euler V-E+F==2. Dual-panel still shows a through-hole and loose-vert bead derived from live mesh incidence — same brass on both so color alone cannot carry the proof.</p>
   </header>
   <main id="main">
     <button class="detail-hero" id="heroZoom" type="button" aria-label="Zoom mesh-hygiene-audit render">
       <img src="../assets/mesh-hygiene-audit-hero.webp" alt="mesh-hygiene-audit render" 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> AI pipelines that skip topology gates ship ngons, loose verts, open boundaries, inverted winding, or non-sphere Euler into engine ingest. Injecting one defect class at a time exits non-zero (ngon=3, loose=4, boundary=5, zero-area=6, flip=7); the clean solid recovers hygiene_ok on both 4.5.11 and 5.1.2.</div>
+    <div class="callout"><span class="tag">witnesses</span> Pipelines that skip topology gates ship open boundaries, loose verts, or non-sphere Euler into engine ingest. The still makes the boundary hole and loose vert readable; ngon / zero-area / full winding invert remain check-only.</div>
     <div class="runline">
       <pre id="runCmd">blender --background --python examples/mesh-hygiene-audit/mesh_hygiene_audit.py --</pre>
       <button class="copy-btn" id="copyRun" type="button">Copy</button>
     </div>
     <section class="detail-section md">
-<p>A runnable example that builds a fabricated street electrical pedestal — stepped plinth, cabinet waist, drip-cap overhang — and runs the <strong>engine-ingest mesh hygiene checklist</strong> as executable topology checks, following <a href="https://github.com/TMHSDigital/Blender-Developer-Tools/tree/main/skills/mesh-editing-and-bmesh/SKILL.md"><code>mesh-editing-and-bmesh</code></a>.</p>
+<p>A runnable example that builds an octagonal street valve body and runs the <strong>engine-ingest mesh hygiene checklist</strong> as executable topology checks, following <a href="https://github.com/TMHSDigital/Blender-Developer-Tools/tree/main/skills/mesh-editing-and-bmesh/SKILL.md"><code>mesh-editing-and-bmesh</code></a>.</p>
 <p><strong>Pipeline arc neighbors:</strong> watertight / Euler on collision *hulls* in <a href="https://github.com/TMHSDigital/Blender-Developer-Tools/tree/main/examples/collision-hull-proxy"><code>collision-hull-proxy</code></a>, parametric closed solids in <a href="https://github.com/TMHSDigital/Blender-Developer-Tools/tree/main/examples/bmesh-gear"><code>bmesh-gear</code></a>, LOD face budgets in <a href="https://github.com/TMHSDigital/Blender-Developer-Tools/tree/main/examples/lod-decimate-chain"><code>lod-decimate-chain</code></a>, and join context in <a href="https://github.com/TMHSDigital/Blender-Developer-Tools/tree/main/examples/temp-override-join"><code>temp-override-join</code></a>. Hygiene is the gate a prop pipeline runs on the *render* mesh before hull / LOD / export.</p>
-<p><strong>Scope:</strong> this witnesses the bpy-level contract a prop pipeline relies on (tris+quads, no loose verts, manifold edges, no zero-area faces, outward winding, Euler 2 for a closed solid). It is not an engine exporter and does not produce a shippable engine asset — it proves the topology properties such an asset must have.</p>
+<p><strong>Scope:</strong> this witnesses the bpy-level contract a prop pipeline relies on (tris+quads, no loose verts, manifold edges, no zero-area faces, outward winding, Euler 2 for a closed solid). It is not an engine exporter.</p>
 <p><strong>What it witnesses:</strong> every gate is derived from mesh combinatorics or the divergence-theorem volume — never from a prior-run capture:</p>
-<ul><li><strong>No ngons.</strong> <code>len(poly.vertices) &lt;= 4</code> for every face.</li><li><strong>No loose vertices.</strong> Every vert has degree ≥ 1.</li><li><strong>Manifold edges.</strong> Every edge borders exactly 2 faces (closed solid).</li><li><strong>No zero-area faces.</strong> Face area &gt; 1e-10; prints measured <code>min_area</code>.</li><li><strong>Outward winding.</strong> Positive signed volume (divergence theorem).</li><li><strong>Euler sphere.</strong> <code>V − E + F == 2</code> for the clean closed manifold (measured: verts=24 edges=44 faces=22, volume≈0.989248).</li></ul>
+<ul><li><strong>No ngons.</strong> <code>len(poly.vertices) &lt;= 4</code> for every face.</li><li><strong>No loose vertices.</strong> Every vert has degree ≥ 1.</li><li><strong>Manifold edges.</strong> Every edge borders exactly 2 faces (closed solid).</li><li><strong>No zero-area faces.</strong> Face area &gt; 1e-10; prints measured <code>min_area</code>.</li><li><strong>Outward winding.</strong> Positive signed volume (divergence theorem).</li><li><strong>Euler sphere.</strong> <code>V − E + F == 2</code> for the clean closed manifold (measured: verts=66 edges=136 faces=72, volume≈0.652001, min_area≈1.146e-02).</li></ul>
 <p><strong>What each check catches on failure:</strong> loose vert injected (exit 4); face deleted → boundary edges (exit 5); edge dissolved → ngon (exit 3); all faces flipped → signed volume negated (exit 7); face collapsed → zero-area (exit 6).</p>
-<p><strong>Version witness:</strong> output is byte-identical on Blender 4.5.11 LTS and 5.1.2 — same counts, same volume, same <code>min_area</code>. The bmesh edge/face incidence and polygon vertex-count APIs are stable across the pair.</p>
-<p>The render is a dual panel: left <strong>DIRTY</strong> (boundary hole + loose-vert bead, emissive hazard + wireframe) vs right <strong>CLEAN</strong> manifold. Failure = identical panels or missing defect cues.</p>
+<p><strong>Version witness:</strong> output is byte-identical on Blender 4.5.11 LTS and 5.1.2 — same counts, same volume, same <code>min_area</code>.</p>
+<p><strong>Render as proof:</strong> dual panel, same brass on both. DIRTY stages a camera-facing through-hole (boundary edges) plus a loose vert; emissive beads/edge tubes are built from the live mesh incidence the check uses — not decorative paint. CLEAN is the intact manifold. A warm card behind the hole makes the void readable against the backdrop.</p>
+<p><strong>Not depicted in the still (check-proven only):</strong> ngon dissolve, zero-area collapse, and full-mesh winding invert — they do not read as geometry at thumbnail scale without faking annotation.</p>
 <h2>Run</h2>
-<pre><code># Cheap correctness check (no render) — the CI check:
-blender --background --python mesh_hygiene_audit.py --
-
-# Also render a still (EEVEE on a GPU host; use --engine cycles on GPU-less hosts):
+<pre><code>blender --background --python mesh_hygiene_audit.py --
 blender --background --python mesh_hygiene_audit.py -- --output hygiene.png
 blender --background --python mesh_hygiene_audit.py -- --output hygiene.png --engine cycles</code></pre>
-<p>It exits non-zero on failure (ngons, loose verts, non-manifold edges, zero-area faces, inverted winding, or Euler ≠ 2). The <code>blender-smoke</code> workflow runs the check on Blender 4.5 LTS and 5.1.</p>
+<p>Exits non-zero on failure. The <code>blender-smoke</code> workflow runs the check on Blender 4.5 LTS and 5.1.</p>
     </section>
     <section class="detail-section src">
       <h2>Source</h2>
@@ -273,43 +271,54 @@ <h2>Source</h2>
 
 
 <span class="k">def</span> build_utility_pedestal():
-    <span class="s">&quot;&quot;&quot;Single closed manifold: street electrical pedestal (fabricated panels).
+    <span class="s">&quot;&quot;&quot;Backward-compat alias — subject is now a street valve body.&quot;&quot;&quot;</span>
+    <span class="k">return</span> build_street_valve()
+
+
+<span class="k">def</span> build_street_valve():
+    <span class="s">&quot;&quot;&quot;Single closed manifold: octagonal street valve body (not a box pedestal).
 
-    Explicit quad ring-stack — flared plinth, cabinet waist, drip-cap flare —
-    so the solid stays quads-only with every edge bordering exactly two faces
-    and Euler V-E+F == 2. Not a beveled cube: the silhouette steps are the
-    authored panels a prop pipeline would audit before ingest.
+    Explicit quad ring-stack with 8-sided flanges + stem so the solid stays
+    quads-only, every edge borders exactly two faces, and Euler V-E+F == 2.
+    Differentiated from prop-origin-transform&#x27;s rectangular pedestal silhouette.
     &quot;&quot;&quot;</span>
-    <span class="c"># (half_x, half_y, z) rings bottom → top</span>
+    <span class="c"># (radius, z) rings bottom → top; each ring is a regular octagon</span>
+    n = <span class="n">8</span>
     rings = [
-        (<span class="n">0.58</span>, <span class="n">0.48</span>, <span class="n">0.00</span>),  <span class="c"># plinth base</span>
-        (<span class="n">0.58</span>, <span class="n">0.48</span>, <span class="n">0.18</span>),  <span class="c"># plinth top</span>
-        (<span class="n">0.45</span>, <span class="n">0.35</span>, <span class="n">0.18</span>),  <span class="c"># cabinet base (inset step)</span>
-        (<span class="n">0.45</span>, <span class="n">0.35</span>, <span class="n">1.30</span>),  <span class="c"># cabinet top</span>
-        (<span class="n">0.52</span>, <span class="n">0.40</span>, <span class="n">1.30</span>),  <span class="c"># drip-cap overhang</span>
-        (<span class="n">0.52</span>, <span class="n">0.40</span>, <span class="n">1.40</span>),  <span class="c"># drip-cap top</span>
+        (<span class="n">0.62</span>, <span class="n">0.00</span>),  <span class="c"># base flange</span>
+        (<span class="n">0.62</span>, <span class="n">0.14</span>),
+        (<span class="n">0.40</span>, <span class="n">0.14</span>),  <span class="c"># body inset</span>
+        (<span class="n">0.40</span>, <span class="n">0.95</span>),
+        (<span class="n">0.55</span>, <span class="n">0.95</span>),  <span class="c"># top flange</span>
+        (<span class="n">0.55</span>, <span class="n">1.08</span>),
+        (<span class="n">0.18</span>, <span class="n">1.08</span>),  <span class="c"># stem</span>
+        (<span class="n">0.18</span>, <span class="n">1.32</span>),
     ]
 
-    me = bpy.data.meshes.new(<span class="s">&quot;UtilityPedestal&quot;</span>)
+    me = bpy.data.meshes.new(<span class="s">&quot;StreetValve&quot;</span>)
     bm = bmesh.new()
     <span class="k">try</span>:
         ring_verts = []
-        <span class="k">for</span> hx, hy, z <span class="k">in</span> rings:
-            ring_verts.append([
-                bm.verts.new((-hx, -hy, z)),
-                bm.verts.new((hx, -hy, z)),
-                bm.verts.new((hx, hy, z)),
-                bm.verts.new((-hx, hy, z)),
-            ])
+        <span class="k">for</span> r, z <span class="k">in</span> rings:
+            ring = []
+            <span class="k">for</span> i <span class="k">in</span> range(n):
+                a = <span class="n">2.0</span> * math.pi * i / n + math.pi / n  <span class="c"># flat-to-camera bias</span>
+                ring.append(bm.verts.new((r * math.cos(a), r * math.sin(a), z)))
+            ring_verts.append(ring)
         <span class="k">for</span> i <span class="k">in</span> range(len(ring_verts) - <span class="n">1</span>):
             a, b = ring_verts[i], ring_verts[i + <span class="n">1</span>]
-            <span class="k">for</span> k <span class="k">in</span> range(<span class="n">4</span>):
-                n = (k + <span class="n">1</span>) % <span class="n">4</span>
-                bm.faces.new((a[k], a[n], b[n], b[k]))
-        bot = ring_verts[<span class="n">0</span>]
-        bm.faces.new((bot[<span class="n">0</span>], bot[<span class="n">3</span>], bot[<span class="n">2</span>], bot[<span class="n">1</span>]))
-        top = ring_verts[-<span class="n">1</span>]
-        bm.faces.new((top[<span class="n">0</span>], top[<span class="n">1</span>], top[<span class="n">2</span>], top[<span class="n">3</span>]))
+            <span class="k">for</span> k <span class="k">in</span> range(n):
+                kn = (k + <span class="n">1</span>) % n
+                bm.faces.new((a[k], a[kn], b[kn], b[k]))
+        bot, top = ring_verts[<span class="n">0</span>], ring_verts[-<span class="n">1</span>]
+        <span class="c"># fan caps as quads via center verts would add poles; use triangle fan</span>
+        <span class="c"># from a center → tris only on caps (still &lt;=4). Prefer center poles.</span>
+        bot_c = bm.verts.new((<span class="n">0.0</span>, <span class="n">0.0</span>, rings[<span class="n">0</span>][<span class="n">1</span>]))
+        top_c = bm.verts.new((<span class="n">0.0</span>, <span class="n">0.0</span>, rings[-<span class="n">1</span>][<span class="n">1</span>]))
+        <span class="k">for</span> k <span class="k">in</span> range(n):
+            kn = (k + <span class="n">1</span>) % n
+            bm.faces.new((bot_c, bot[kn], bot[k]))  <span class="c"># outward -Z</span>
+            bm.faces.new((top_c, top[k], top[kn]))  <span class="c"># outward +Z</span>
 
         bmesh.ops.recalc_face_normals(bm, faces=bm.faces)
         tmp = bpy.data.meshes.new(<span class="s">&quot;_tmp_vol&quot;</span>)
@@ -330,11 +339,12 @@ <h2>Source</h2>
     <span class="k">finally</span>:
         bm.free()
 
-    mat = make_material(<span class="s">&quot;PedestalSteel&quot;</span>, (<span class="n">0.18</span>, <span class="n">0.42</span>, <span class="n">0.38</span>), rough=<span class="n">0.42</span>, metallic=<span class="n">0.55</span>)
+    <span class="c"># Brass / copper — distinct from prop-origin teal pedestal</span>
+    mat = make_material(<span class="s">&quot;ValveBrass&quot;</span>, (<span class="n">0.55</span>, <span class="n">0.38</span>, <span class="n">0.14</span>), rough=<span class="n">0.38</span>, metallic=<span class="n">0.85</span>)
     me.materials.append(mat)
     <span class="k">for</span> p <span class="k">in</span> me.polygons:
-        p.use_smooth = <span class="k">False</span>
-    ob = bpy.data.objects.new(<span class="s">&quot;UtilityPedestal&quot;</span>, me)
+        p.use_smooth = abs(p.normal.z) &lt; <span class="n">0.85</span>
+    ob = bpy.data.objects.new(<span class="s">&quot;StreetValve&quot;</span>, me)
     bpy.context.collection.objects.link(ob)
     <span class="k">return</span> ob
 
@@ -440,14 +450,20 @@ <h2>Source</h2>
             <span class="c"># next to the subject (not halfway to the clean panel).</span>
             bm.verts.new((<span class="n">0.0</span>, -<span class="n">0.55</span>, <span class="n">0.85</span>))
         <span class="k">elif</span> kind == <span class="s">&quot;boundary&quot;</span>:
-            <span class="c"># Prefer a large side face so the hole reads in the dual-panel still.</span>
+            <span class="c"># Prefer a large camera-facing (-Y) face so the hole reads through</span>
+            <span class="c"># to the lit backdrop in the dual-panel still.</span>
             faces = sorted(bm.faces, key=<span class="k">lambda</span> f: -f.calc_area())
             target = <span class="k">None</span>
             <span class="k">for</span> f <span class="k">in</span> faces:
                 n = f.normal
-                <span class="k">if</span> abs(n.x) &gt; <span class="n">0.7</span>:  <span class="c"># side panel</span>
+                <span class="k">if</span> n.y &lt; -<span class="n">0.55</span>:
                     target = f
                     <span class="k">break</span>
+            <span class="k">if</span> target <span class="k">is</span> <span class="k">None</span>:
+                <span class="k">for</span> f <span class="k">in</span> faces:
+                    <span class="k">if</span> abs(f.normal.x) &gt; <span class="n">0.7</span>:
+                        target = f
+                        <span class="k">break</span>
             <span class="k">if</span> target <span class="k">is</span> <span class="k">None</span> <span class="k">and</span> faces:
                 target = faces[<span class="n">0</span>]
             <span class="k">if</span> target <span class="k">is</span> <span class="k">not</span> <span class="k">None</span>:
@@ -525,90 +541,121 @@ <h2>Source</h2>
     <span class="k">return</span> ob
 
 
-<span class="k">def</span> mark_defects(ob):
-    <span class="s">&quot;&quot;&quot;Emissive hazard material + wireframe so defects read in-frame.&quot;&quot;&quot;</span>
-    mat = make_material(
-        <span class="s">&quot;Hazard&quot;</span>, (<span class="n">0.75</span>, <span class="n">0.18</span>, <span class="n">0.08</span>), rough=<span class="n">0.5</span>, metallic=<span class="n">0.25</span>,
-        emit=(<span class="n">1.0</span>, <span class="n">0.3</span>, <span class="n">0.05</span>), estr=<span class="n">0.85</span>,
-    )
-    wire_mat = make_material(
-        <span class="s">&quot;HazardWire&quot;</span>, (<span class="n">1.0</span>, <span class="n">0.35</span>, <span class="n">0.05</span>), rough=<span class="n">0.4</span>, metallic=<span class="n">0.0</span>,
-        emit=(<span class="n">1.0</span>, <span class="n">0.4</span>, <span class="n">0.05</span>), estr=<span class="n">2.0</span>,
-    )
-    ob.data.materials.clear()
-    ob.data.materials.append(mat)
-    ob.data.materials.append(wire_mat)
-    wire = bpy.data.objects.new(ob.name + <span class="s">&quot;Wire&quot;</span>, ob.data)
-    mod = wire.modifiers.new(<span class="s">&quot;Wire&quot;</span>, <span class="s">&quot;WIREFRAME&quot;</span>)
-    mod.thickness = <span class="n">0.012</span>
-    mod.material_offset = <span class="n">1</span>
-    bpy.context.scene.collection.objects.link(wire)
-    wire.location = ob.location
+<span class="k">def</span> _inject_through_hole(me):
+    <span class="s">&quot;&quot;&quot;Render staging: delete a front/back body-face pair so the void reads.
+
+    Produces boundary edges (same gate class as inject_defect(&#x27;boundary&#x27;)).
+    Does not change the check path — only the dual-panel still.
+    &quot;&quot;&quot;</span>
+    bm = bmesh.new()
+    <span class="k">try</span>:
+        bm.from_mesh(me)
+        bm.faces.ensure_lookup_table()
+        <span class="c"># Prefer mid-height body faces (not flanges/caps)</span>
+        body = [
+            f <span class="k">for</span> f <span class="k">in</span> bm.faces
+            <span class="k">if</span> abs(f.normal.z) &lt; <span class="n">0.35</span> <span class="k">and</span> <span class="n">0.2</span> &lt; f.calc_center_median().z &lt; <span class="n">0.9</span>
+        ]
+        <span class="k">if</span> <span class="k">not</span> body:
+            body = list(bm.faces)
+        front = max(body, key=<span class="k">lambda</span> f: -f.normal.y * f.calc_area())
+        back = max(body, key=<span class="k">lambda</span> f: f.normal.y * f.calc_area())
+        doomed = [front] <span class="k">if</span> front <span class="k">is</span> back <span class="k">else</span> [front, back]
+        bmesh.ops.delete(bm, geom=doomed, context=<span class="s">&quot;FACES_ONLY&quot;</span>)
+        bm.to_mesh(me)
+        me.update()
+    <span class="k">finally</span>:
+        bm.free()
+
 
+<span class="k">def</span> _defect_geometry(me):
+    <span class="s">&quot;&quot;&quot;Loose-vert coords and boundary edge pairs — same incidence as audit().&quot;&quot;&quot;</span>
     bm = bmesh.new()
     <span class="k">try</span>:
-        bm.from_mesh(ob.data)
-        coords = [v.co.copy() <span class="k">for</span> v <span class="k">in</span> bm.verts <span class="k">if</span> len(v.link_edges) == <span class="n">0</span>]
+        bm.from_mesh(me)
+        bm.verts.ensure_lookup_table()
+        bm.edges.ensure_lookup_table()
+        loose = [v.co.copy() <span class="k">for</span> v <span class="k">in</span> bm.verts <span class="k">if</span> len(v.link_edges) == <span class="n">0</span>]
+        boundary = [
+            (e.verts[<span class="n">0</span>].co.copy(), e.verts[<span class="n">1</span>].co.copy())
+            <span class="k">for</span> e <span class="k">in</span> bm.edges <span class="k">if</span> len(e.link_faces) == <span class="n">1</span>
+        ]
     <span class="k">finally</span>:
         bm.free()
+    <span class="k">return</span> loose, boundary
+
+
+<span class="k">def</span> mark_defects_from_audit(ob):
+    <span class="s">&quot;&quot;&quot;Overlay markers from live mesh defects — not decorative paint.
+
+    Loose verts → emissive beads at measured local coords.
+    Boundary edges → emissive tubes along those edge endpoints.
+    Body keeps the same brass as CLEAN so the difference is topological.
+    &quot;&quot;&quot;</span>
+    sc = bpy.context.scene
+    loose, boundary = _defect_geometry(ob.data)
+    metrics = audit(ob.data)
+    print(
+        <span class="s">f&quot;</span><span class="s">render_defects loose=</span>{metrics[<span class="s">&#x27;loose&#x27;</span>]}<span class="s"> boundary_edges=</span>{metrics[<span class="s">&#x27;boundary&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">ngons=</span>{metrics[<span class="s">&#x27;ngons&#x27;</span>]}<span class="s"> zero_area=</span>{metrics[<span class="s">&#x27;zero_area&#x27;</span>]}<span class="s">&quot;</span>
+    )
+
+    brass = make_material(<span class="s">&quot;DirtyBrass&quot;</span>, (<span class="n">0.55</span>, <span class="n">0.38</span>, <span class="n">0.14</span>), rough=<span class="n">0.38</span>, metallic=<span class="n">0.85</span>)
+    ob.data.materials.clear()
+    ob.data.materials.append(brass)
+
     bead_mat = make_material(
-        <span class="s">&quot;LooseBead&quot;</span>, (<span class="n">1.0</span>, <span class="n">0.9</span>, <span class="n">0.2</span>), rough=<span class="n">0.3</span>, metallic=<span class="n">0.0</span>,
-        emit=(<span class="n">1.0</span>, <span class="n">0.85</span>, <span class="n">0.1</span>), estr=<span class="n">2.5</span>,
+        <span class="s">&quot;LooseBead&quot;</span>, (<span class="n">1.0</span>, <span class="n">0.85</span>, <span class="n">0.15</span>), rough=<span class="n">0.3</span>, metallic=<span class="n">0.0</span>,
+        emit=(<span class="n">1.0</span>, <span class="n">0.9</span>, <span class="n">0.2</span>), estr=<span class="n">3.0</span>,
     )
-    sc = bpy.context.scene
-    <span class="k">for</span> i, co <span class="k">in</span> enumerate(coords):
-        sme = bpy.data.meshes.new(<span class="s">f&quot;</span><span class="s">Bead</span>{i}<span class="s">&quot;</span>)
+    <span class="k">for</span> i, co <span class="k">in</span> enumerate(loose):
+        sme = bpy.data.meshes.new(<span class="s">f&quot;</span><span class="s">LooseBead</span>{i}<span class="s">&quot;</span>)
         sbm = bmesh.new()
         <span class="k">try</span>:
-            bmesh.ops.create_uvsphere(sbm, u_segments=<span class="n">8</span>, v_segments=<span class="n">6</span>, radius=<span class="n">0.07</span>)
+            bmesh.ops.create_uvsphere(sbm, u_segments=<span class="n">10</span>, v_segments=<span class="n">8</span>, radius=<span class="n">0.055</span>)
             sbm.to_mesh(sme)
         <span class="k">finally</span>:
             sbm.free()
         sme.materials.append(bead_mat)
-        sob = bpy.data.objects.new(<span class="s">f&quot;</span><span class="s">Bead</span>{i}<span class="s">&quot;</span>, sme)
+        sob = bpy.data.objects.new(<span class="s">f&quot;</span><span class="s">LooseBead</span>{i}<span class="s">&quot;</span>, sme)
         sob.location = Vector(ob.location) + co
         sc.collection.objects.link(sob)
 
-
-<span class="k">def</span> add_door_dressing(sc, parent_loc, suffix):
-    <span class="s">&quot;&quot;&quot;Non-audited door plaque + bolts — silhouette only, not in the check mesh.&quot;&quot;&quot;</span>
-    door_m = make_material(<span class="s">f&quot;</span><span class="s">Door</span>{suffix}<span class="s">&quot;</span>, (<span class="n">0.16</span>, <span class="n">0.20</span>, <span class="n">0.18</span>), rough=<span class="n">0.4</span>, metallic=<span class="n">0.65</span>)
-    bolt_m = make_material(<span class="s">f&quot;</span><span class="s">Bolt</span>{suffix}<span class="s">&quot;</span>, (<span class="n">0.55</span>, <span class="n">0.45</span>, <span class="n">0.22</span>), rough=<span class="n">0.35</span>, metallic=<span class="n">0.85</span>)
-    <span class="c"># door plaque</span>
-    me = bpy.data.meshes.new(<span class="s">f&quot;</span><span class="s">Door</span>{suffix}<span class="s">&quot;</span>)
-    bm = bmesh.new()
-    <span class="k">try</span>:
-        bmesh.ops.create_cube(bm, size=<span class="n">1.0</span>)
-        bmesh.ops.transform(
-            bm, matrix=Matrix.Diagonal((<span class="n">0.55</span>, <span class="n">0.03</span>, <span class="n">0.85</span>, <span class="n">1.0</span>)), verts=bm.verts,
-        )
-        bm.to_mesh(me)
-    <span class="k">finally</span>:
-        bm.free()
-    me.materials.append(door_m)
-    door = bpy.data.objects.new(<span class="s">f&quot;</span><span class="s">Door</span>{suffix}<span class="s">&quot;</span>, me)
-    door.location = (parent_loc[<span class="n">0</span>], parent_loc[<span class="n">1</span>] - <span class="n">0.365</span>, parent_loc[<span class="n">2</span>] + <span class="n">0.75</span>)
-    sc.collection.objects.link(door)
-    <span class="k">for</span> x, z <span class="k">in</span> ((-<span class="n">0.18</span>, <span class="n">0.45</span>), (<span class="n">0.18</span>, <span class="n">0.45</span>), (-<span class="n">0.18</span>, <span class="n">1.05</span>), (<span class="n">0.18</span>, <span class="n">1.05</span>)):
-        bme = bpy.data.meshes.new(<span class="s">f&quot;</span><span class="s">Bolt</span>{suffix}<span class="s">_</span>{x}<span class="s">_</span>{z}<span class="s">&quot;</span>)
-        bbm = bmesh.new()
+    edge_mat = make_material(
+        <span class="s">&quot;BoundaryEdge&quot;</span>, (<span class="n">1.0</span>, <span class="n">0.25</span>, <span class="n">0.05</span>), rough=<span class="n">0.35</span>, metallic=<span class="n">0.0</span>,
+        emit=(<span class="n">1.0</span>, <span class="n">0.35</span>, <span class="n">0.05</span>), estr=<span class="n">2.8</span>,
+    )
+    <span class="k">for</span> i, (a, b) <span class="k">in</span> enumerate(boundary):
+        mid = (a + b) * <span class="n">0.5</span>
+        direction = b - a
+        length = direction.length
+        <span class="k">if</span> length &lt; <span class="n">1e-8</span>:
+            <span class="k">continue</span>
+        eme = bpy.data.meshes.new(<span class="s">f&quot;</span><span class="s">Bnd</span>{i}<span class="s">&quot;</span>)
+        ebm = bmesh.new()
         <span class="k">try</span>:
             bmesh.ops.create_cone(
-                bbm, cap_ends=<span class="k">True</span>, segments=<span class="n">10</span>, radius1=<span class="n">0.03</span>, radius2=<span class="n">0.03</span>, depth=<span class="n">0.04</span>,
+                ebm, cap_ends=<span class="k">True</span>, segments=<span class="n">6</span>,
+                radius1=<span class="n">0.018</span>, radius2=<span class="n">0.018</span>, depth=length,
             )
-            bbm.to_mesh(bme)
+            ebm.to_mesh(eme)
         <span class="k">finally</span>:
-            bbm.free()
-        bme.materials.append(bolt_m)
-        bob = bpy.data.objects.new(<span class="s">f&quot;</span><span class="s">Bolt</span>{suffix}<span class="s">_</span>{x}<span class="s">_</span>{z}<span class="s">&quot;</span>, bme)
-        bob.location = (parent_loc[<span class="n">0</span>] + x, parent_loc[<span class="n">1</span>] - <span class="n">0.39</span>, parent_loc[<span class="n">2</span>] + z)
-        sc.collection.objects.link(bob)
+            ebm.free()
+        eme.materials.append(edge_mat)
+        eob = bpy.data.objects.new(<span class="s">f&quot;</span><span class="s">Bnd</span>{i}<span class="s">&quot;</span>, eme)
+        eob.location = Vector(ob.location) + mid
+        quat = direction.normalized().to_track_quat(<span class="s">&quot;Z&quot;</span>, <span class="s">&quot;Y&quot;</span>)
+        eob.rotation_mode = <span class="s">&quot;QUATERNION&quot;</span>
+        eob.rotation_quaternion = quat
+        sc.collection.objects.link(eob)
+
+    <span class="k">return</span> metrics
 
 
-<span class="k">def</span> placard(sc, text, loc):
+<span class="k">def</span> placard(sc, text, loc, size=<span class="n">0.18</span>):
     cu = bpy.data.curves.new(text, <span class="s">&quot;FONT&quot;</span>)
     cu.body = text
-    cu.size = <span class="n">0.22</span>
+    cu.size = size
     cu.align_x = <span class="s">&quot;CENTER&quot;</span>
     ob = bpy.data.objects.new(text, cu)
     ob.location = loc
@@ -619,36 +666,67 @@ <h2>Source</h2>
 
 
 <span class="k">def</span> render_still(clean_ob, path, engine):
-    <span class="s">&quot;&quot;&quot;Dual-panel dirty (left) vs clean (right) — contract at a glance.&quot;&quot;&quot;</span>
+    <span class="s">&quot;&quot;&quot;Dual-panel dirty vs clean — topology defects visible in the pixels.
+
+    DIRTY: camera-facing boundary hole + loose vert; overlays from audit data.
+    CLEAN: intact manifold. Same brass on both so color alone cannot carry proof.
+
+    Ngons / zero-area / full winding invert are check-proven but not staged
+    (see README) — they do not read as geometry at thumbnail scale without faking.
+    &quot;&quot;&quot;</span>
     sc = bpy.context.scene
     clean_ob.hide_render = <span class="k">True</span>
     clean_ob.hide_viewport = <span class="k">True</span>
 
-    left = _duplicate_mesh_obj(sc, clean_ob, <span class="s">&quot;Dirty&quot;</span>, (-<span class="n">1.35</span>, <span class="n">0.0</span>, <span class="n">0.0</span>))
-    inject_defect(left.data, <span class="s">&quot;boundary&quot;</span>)
+    left = _duplicate_mesh_obj(sc, clean_ob, <span class="s">&quot;Dirty&quot;</span>, (-<span class="n">1.15</span>, <span class="n">0.0</span>, <span class="n">0.0</span>))
+    left.rotation_euler.z = math.radians(<span class="n">22.5</span>)
+    bpy.context.view_layer.update()
+    _inject_through_hole(left.data)
     inject_defect(left.data, <span class="s">&quot;loose&quot;</span>)
-    mark_defects(left)
-    add_door_dressing(sc, (-<span class="n">1.35</span>, <span class="n">0.0</span>, <span class="n">0.0</span>), <span class="s">&quot;Dirty&quot;</span>)
+    mark_defects_from_audit(left)
 
-    right = _duplicate_mesh_obj(sc, clean_ob, <span class="s">&quot;Clean&quot;</span>, (<span class="n">1.35</span>, <span class="n">0.0</span>, <span class="n">0.0</span>))
+    right = _duplicate_mesh_obj(sc, clean_ob, <span class="s">&quot;Clean&quot;</span>, (<span class="n">1.15</span>, <span class="n">0.0</span>, <span class="n">0.0</span>))
+    right.rotation_euler.z = math.radians(-<span class="n">12</span>)
     right.data.materials.clear()
     right.data.materials.append(
-        make_material(<span class="s">&quot;CleanSteel&quot;</span>, (<span class="n">0.18</span>, <span class="n">0.42</span>, <span class="n">0.38</span>), rough=<span class="n">0.42</span>, metallic=<span class="n">0.55</span>)
+        make_material(<span class="s">&quot;CleanBrass&quot;</span>, (<span class="n">0.55</span>, <span class="n">0.38</span>, <span class="n">0.14</span>), rough=<span class="n">0.38</span>, metallic=<span class="n">0.85</span>)
     )
-    add_door_dressing(sc, (<span class="n">1.35</span>, <span class="n">0.0</span>, <span class="n">0.0</span>), <span class="s">&quot;Clean&quot;</span>)
+    <span class="k">for</span> p <span class="k">in</span> right.data.polygons:
+        p.use_smooth = abs(p.normal.z) &lt; <span class="n">0.85</span>
 
-    placard(sc, <span class="s">&quot;DIRTY&quot;</span>, (-<span class="n">1.35</span>, -<span class="n">0.85</span>, <span class="n">0.02</span>))
-    placard(sc, <span class="s">&quot;CLEAN&quot;</span>, (<span class="n">1.35</span>, -<span class="n">0.85</span>, <span class="n">0.02</span>))
+    placard(sc, <span class="s">&quot;DIRTY&quot;</span>, (-<span class="n">1.15</span>, -<span class="n">1.0</span>, <span class="n">0.02</span>), size=<span class="n">0.15</span>)
+    placard(sc, <span class="s">&quot;CLEAN&quot;</span>, (<span class="n">1.15</span>, -<span class="n">1.0</span>, <span class="n">0.02</span>), size=<span class="n">0.15</span>)
 
     build_studio(sc)
+    <span class="c"># Lit card behind DIRTY so the through-hole voids read against warm light</span>
+    card_me = bpy.data.meshes.new(<span class="s">&quot;HoleCard&quot;</span>)
+    cbm = bmesh.new()
+    <span class="k">try</span>:
+        bmesh.ops.create_grid(cbm, x_segments=<span class="n">1</span>, y_segments=<span class="n">1</span>, size=<span class="n">1.2</span>)
+        cbm.to_mesh(card_me)
+    <span class="k">finally</span>:
+        cbm.free()
+    card_mat = make_material(
+        <span class="s">&quot;HoleCard&quot;</span>, (<span class="n">1.0</span>, <span class="n">0.55</span>, <span class="n">0.25</span>), rough=<span class="n">0.9</span>, metallic=<span class="n">0.0</span>,
+        emit=(<span class="n">1.0</span>, <span class="n">0.55</span>, <span class="n">0.2</span>), estr=<span class="n">1.8</span>,
+    )
+    card_me.materials.append(card_mat)
+    card = bpy.data.objects.new(<span class="s">&quot;HoleCard&quot;</span>, card_me)
+    card.location = (-<span class="n">1.15</span>, <span class="n">1.4</span>, <span class="n">0.65</span>)
+    card.rotation_euler = (math.radians(<span class="n">90</span>), <span class="n">0.0</span>, <span class="n">0.0</span>)
+    sc.collection.objects.link(card)
+    <span class="k">for</span> ob <span class="k">in</span> sc.objects:
+        <span class="k">if</span> ob.type == <span class="s">&quot;LIGHT&quot;</span> <span class="k">and</span> ob.name == <span class="s">&quot;Wedge&quot;</span>:
+            ob.data.energy = <span class="n">580.0</span>
+            ob.location = (<span class="n">0.0</span>, <span class="n">6.5</span>, <span class="n">3.5</span>)
 
     cam_data = bpy.data.cameras.new(<span class="s">&quot;Cam&quot;</span>)
-    cam_data.lens = <span class="n">48.0</span>
+    cam_data.lens = <span class="n">50.0</span>
     cam = bpy.data.objects.new(<span class="s">&quot;Cam&quot;</span>, cam_data)
-    cam.location = (<span class="n">0.55</span>, -<span class="n">5.0</span>, <span class="n">1.55</span>)
+    cam.location = (<span class="n">0.1</span>, -<span class="n">5.6</span>, <span class="n">1.5</span>)
     sc.collection.objects.link(cam)
     aim = bpy.data.objects.new(<span class="s">&quot;Aim&quot;</span>, <span class="k">None</span>)
-    aim.location = (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.70</span>)
+    aim.location = (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.62</span>)
     sc.collection.objects.link(aim)
     tr = cam.constraints.new(<span class="s">&quot;TRACK_TO&quot;</span>)
     tr.target = aim
@@ -677,7 +755,7 @@ <h2>Source</h2>
 
 <span class="k">def</span> build_scene():
     bpy.ops.wm.read_factory_settings(use_empty=<span class="k">True</span>)
-    <span class="k">return</span> bpy.context.scene, build_utility_pedestal()
+    <span class="k">return</span> bpy.context.scene, build_street_valve()
 
 
 <span class="k">def</span> main():
diff --git a/docs/gallery/prop-origin-transform/index.html b/docs/gallery/prop-origin-transform/index.html
index 2201fdf..3b5cbc4 100644
--- a/docs/gallery/prop-origin-transform/index.html
+++ b/docs/gallery/prop-origin-transform/index.html
@@ -4,18 +4,18 @@
   <meta charset="utf-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1" />
   <title>prop-origin-transform — Examples — Blender Developer Tools</title>
-  <meta name="description" content="Street pedestal origin-to-base-center + data-API scale apply + matrix_parent_inverse for a bolted accessory. After bake: scale exactly (1,1,1), local min.z==0, world AABB delta 0. Bare parent jumps the accessory (~0.43 m); MPI restores world location (~3e-8). view_layer.update() before reading matrix_world." />
+  <meta name="description" content="Street pedestal origin-to-base-center + data-API scale apply + matrix_parent_inverse for a flanged conduit accessory. After bake: scale (1,1,1), local min.z==0, world AABB unchanged. Bare parent jumps the accessory off an empty mount socket; MPI keeps it seated." />
   <link rel="canonical" href="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/prop-origin-transform/" />
   <link rel="icon" href="../../assets/favicon.svg" type="image/svg+xml" />
   <meta name="theme-color" content="#1a1b1e" />
   <meta property="og:type" content="website" />
   <meta property="og:title" content="prop-origin-transform — Examples — Blender Developer Tools" />
-  <meta property="og:description" content="Street pedestal origin-to-base-center + data-API scale apply + matrix_parent_inverse for a bolted accessory. After bake: scale exactly (1,1,1), local min.z==0, world AABB delta 0. Bare parent jumps the accessory (~0.43 m); MPI restores world location (~3e-8). view_layer.update() before reading matrix_world." />
+  <meta property="og:description" content="Street pedestal origin-to-base-center + data-API scale apply + matrix_parent_inverse for a flanged conduit accessory. After bake: scale (1,1,1), local min.z==0, world AABB unchanged. Bare parent jumps the accessory off an empty mount socket; MPI keeps it seated." />
   <meta property="og:url" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/prop-origin-transform/" />
   <meta property="og:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/prop-origin-transform-hero.webp" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="prop-origin-transform — Examples — Blender Developer Tools" />
-  <meta name="twitter:description" content="Street pedestal origin-to-base-center + data-API scale apply + matrix_parent_inverse for a bolted accessory. After bake: scale exactly (1,1,1), local min.z==0, world AABB delta 0. Bare parent jumps the accessory (~0.43 m); MPI restores world location (~3e-8). view_layer.update() before reading matrix_world." />
+  <meta name="twitter:description" content="Street pedestal origin-to-base-center + data-API scale apply + matrix_parent_inverse for a flanged conduit accessory. After bake: scale (1,1,1), local min.z==0, world AABB unchanged. Bare parent jumps the accessory off an empty mount socket; MPI keeps it seated." />
   <meta name="twitter:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/prop-origin-transform-hero.webp" />
   <style>
     /* fonts are deployed by the landing build (docs/fonts/) */
@@ -170,14 +170,14 @@
   </div>
   <header class="hero">
     <h1>prop-origin-transform</h1>
-    <p>Street pedestal origin-to-base-center + data-API scale apply + matrix_parent_inverse for a bolted accessory. After bake: scale exactly (1,1,1), local min.z==0, world AABB delta 0. Bare parent jumps the accessory (~0.43 m); MPI restores world location (~3e-8). view_layer.update() before reading matrix_world.</p>
+    <p>Street pedestal origin-to-base-center + data-API scale apply + matrix_parent_inverse for a flanged conduit accessory. After bake: scale (1,1,1), local min.z==0, world AABB unchanged. Bare parent jumps the accessory off an empty mount socket; MPI keeps it seated.</p>
   </header>
   <main id="main">
     <button class="detail-hero" id="heroZoom" type="button" aria-label="Zoom prop-origin-transform render">
       <img src="../assets/prop-origin-transform-hero.webp" alt="prop-origin-transform render" 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> AI code parents with child.parent = parent alone (accessory teleports), skips view_layer.update() before matrix_world, or leaves non-uniform scale / centered origin for engine ingest. Skipping apply, origin bake, or MPI each fails a closed-form gate.</div>
+    <div class="callout"><span class="tag">witnesses</span> Bare child.parent = parent teleports accessories off their mounts; skipping view_layer.update() before matrix_world, or leaving non-uniform scale / centered origin, breaks engine ingest placement.</div>
     <div class="runline">
       <pre id="runCmd">blender --background --python examples/prop-origin-transform/prop_origin_transform.py --</pre>
       <button class="copy-btn" id="copyRun" type="button">Copy</button>
@@ -315,17 +315,64 @@ <h2>Source</h2>
 
 
 <span class="k">def</span> build_accessory_mesh():
-    <span class="s">&quot;&quot;&quot;Small conduit elbow — bolted accessory for the MPI trap.&quot;&quot;&quot;</span>
+    <span class="s">&quot;&quot;&quot;Flanged conduit stub — reads as a bolted part, not a stray cylinder.&quot;&quot;&quot;</span>
     me = bpy.data.meshes.new(<span class="s">&quot;Conduit&quot;</span>)
     bm = bmesh.new()
     <span class="k">try</span>:
+        <span class="c"># Barrel along +Y (away from prop face when mounted)</span>
         bmesh.ops.create_cone(
-            bm, cap_ends=<span class="k">True</span>, segments=<span class="n">12</span>, radius1=<span class="n">0.07</span>, radius2=<span class="n">0.07</span>, depth=<span class="n">0.35</span>,
+            bm, cap_ends=<span class="k">True</span>, segments=<span class="n">14</span>, radius1=<span class="n">0.08</span>, radius2=<span class="n">0.08</span>, depth=<span class="n">0.42</span>,
         )
         bmesh.ops.rotate(
             bm, verts=bm.verts, cent=(<span class="n">0</span>, <span class="n">0</span>, <span class="n">0</span>),
             matrix=Matrix.Rotation(math.radians(<span class="n">90</span>), <span class="n">4</span>, <span class="s">&quot;X&quot;</span>),
         )
+        bmesh.ops.translate(bm, vec=(<span class="n">0.0</span>, -<span class="n">0.21</span>, <span class="n">0.0</span>), verts=bm.verts)
+        <span class="c"># Mounting flange at the prop-facing end</span>
+        ret = bmesh.ops.create_cone(
+            bm, cap_ends=<span class="k">True</span>, segments=<span class="n">16</span>, radius1=<span class="n">0.16</span>, radius2=<span class="n">0.16</span>, depth=<span class="n">0.04</span>,
+        )
+        bmesh.ops.rotate(
+            bm, verts=ret[<span class="s">&quot;verts&quot;</span>], cent=(<span class="n">0</span>, <span class="n">0</span>, <span class="n">0</span>),
+            matrix=Matrix.Rotation(math.radians(<span class="n">90</span>), <span class="n">4</span>, <span class="s">&quot;X&quot;</span>),
+        )
+        bmesh.ops.translate(bm, vec=(<span class="n">0.0</span>, <span class="n">0.02</span>, <span class="n">0.0</span>), verts=ret[<span class="s">&quot;verts&quot;</span>])
+        <span class="c"># Four bolt heads on the flange</span>
+        <span class="k">for</span> ang <span class="k">in</span> (<span class="n">45</span>, <span class="n">135</span>, <span class="n">225</span>, <span class="n">315</span>):
+            rad = math.radians(ang)
+            bx, bz = <span class="n">0.11</span> * math.cos(rad), <span class="n">0.11</span> * math.sin(rad)
+            br = bmesh.ops.create_cone(
+                bm, cap_ends=<span class="k">True</span>, segments=<span class="n">8</span>, radius1=<span class="n">0.025</span>, radius2=<span class="n">0.025</span>, depth=<span class="n">0.03</span>,
+            )
+            bmesh.ops.rotate(
+                bm, verts=br[<span class="s">&quot;verts&quot;</span>], cent=(<span class="n">0</span>, <span class="n">0</span>, <span class="n">0</span>),
+                matrix=Matrix.Rotation(math.radians(<span class="n">90</span>), <span class="n">4</span>, <span class="s">&quot;X&quot;</span>),
+            )
+            bmesh.ops.translate(bm, vec=(bx, <span class="n">0.05</span>, bz), verts=br[<span class="s">&quot;verts&quot;</span>])
+        bm.to_mesh(me)
+    <span class="k">finally</span>:
+        bm.free()
+    <span class="k">return</span> me
+
+
+<span class="k">def</span> build_socket_mesh():
+    <span class="s">&quot;&quot;&quot;Empty mount collar left on the prop — the seat the accessory departed.&quot;&quot;&quot;</span>
+    me = bpy.data.meshes.new(<span class="s">&quot;Socket&quot;</span>)
+    bm = bmesh.new()
+    <span class="k">try</span>:
+        <span class="c"># Outer ring</span>
+        bmesh.ops.create_cone(
+            bm, cap_ends=<span class="k">True</span>, segments=<span class="n">20</span>, radius1=<span class="n">0.18</span>, radius2=<span class="n">0.18</span>, depth=<span class="n">0.05</span>,
+        )
+        <span class="c"># Punch a visual recess by adding an inset darker disk slightly proud</span>
+        inner = bmesh.ops.create_cone(
+            bm, cap_ends=<span class="k">True</span>, segments=<span class="n">16</span>, radius1=<span class="n">0.09</span>, radius2=<span class="n">0.09</span>, depth=<span class="n">0.02</span>,
+        )
+        bmesh.ops.translate(bm, vec=(<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.02</span>), verts=inner[<span class="s">&quot;verts&quot;</span>])
+        bmesh.ops.rotate(
+            bm, verts=bm.verts, cent=(<span class="n">0</span>, <span class="n">0</span>, <span class="n">0</span>),
+            matrix=Matrix.Rotation(math.radians(<span class="n">90</span>), <span class="n">4</span>, <span class="s">&quot;X&quot;</span>),
+        )
         bm.to_mesh(me)
     <span class="k">finally</span>:
         bm.free()
@@ -606,15 +653,20 @@ <h2>Source</h2>
 
 <span class="k">def</span> render_still(path, engine):
     <span class="s">&quot;&quot;&quot;Dual panel: bare-parent TRAP (left) vs MPI KEEP (right) + origin at base.&quot;&quot;&quot;</span>
-    <span class="c"># Fresh scene for the still so check mutations don&#x27;t poison framing</span>
     bpy.ops.wm.read_factory_settings(use_empty=<span class="k">True</span>)
     sc = bpy.context.scene
 
-    body_m = make_material(<span class="s">&quot;BodyR&quot;</span>, (<span class="n">0.18</span>, <span class="n">0.42</span>, <span class="n">0.38</span>), rough=<span class="n">0.42</span>, metallic=<span class="n">0.55</span>)
-    acc_m = make_material(<span class="s">&quot;AccR&quot;</span>, (<span class="n">0.55</span>, <span class="n">0.45</span>, <span class="n">0.22</span>), rough=<span class="n">0.35</span>, metallic=<span class="n">0.8</span>)
+    <span class="c"># Teal pedestal — distinct from mesh-hygiene brass valve</span>
+    body_m = make_material(<span class="s">&quot;BodyR&quot;</span>, (<span class="n">0.14</span>, <span class="n">0.48</span>, <span class="n">0.42</span>), rough=<span class="n">0.4</span>, metallic=<span class="n">0.55</span>)
+    acc_m = make_material(<span class="s">&quot;AccR&quot;</span>, (<span class="n">0.62</span>, <span class="n">0.48</span>, <span class="n">0.18</span>), rough=<span class="n">0.35</span>, metallic=<span class="n">0.85</span>)
     trap_m = make_material(
-        <span class="s">&quot;TrapAcc&quot;</span>, (<span class="n">0.9</span>, <span class="n">0.2</span>, <span class="n">0.1</span>), rough=<span class="n">0.4</span>, metallic=<span class="n">0.3</span>,
-        emit=(<span class="n">1.0</span>, <span class="n">0.25</span>, <span class="n">0.05</span>), estr=<span class="n">1.0</span>,
+        <span class="s">&quot;TrapAcc&quot;</span>, (<span class="n">0.95</span>, <span class="n">0.28</span>, <span class="n">0.08</span>), rough=<span class="n">0.4</span>, metallic=<span class="n">0.35</span>,
+        emit=(<span class="n">1.0</span>, <span class="n">0.3</span>, <span class="n">0.05</span>), estr=<span class="n">1.1</span>,
+    )
+    sock_m = make_material(<span class="s">&quot;Socket&quot;</span>, (<span class="n">0.12</span>, <span class="n">0.14</span>, <span class="n">0.15</span>), rough=<span class="n">0.55</span>, metallic=<span class="n">0.4</span>)
+    sock_empty_m = make_material(
+        <span class="s">&quot;SocketEmpty&quot;</span>, (<span class="n">0.35</span>, <span class="n">0.55</span>, <span class="n">0.75</span>), rough=<span class="n">0.45</span>, metallic=<span class="n">0.2</span>,
+        emit=(<span class="n">0.3</span>, <span class="n">0.5</span>, <span class="n">0.75</span>), estr=<span class="n">0.6</span>,
     )
 
     <span class="k">def</span> make_prop(name, loc, rot_z=<span class="n">0.0</span>):
@@ -631,8 +683,6 @@ <h2>Source</h2>
         bpy.context.view_layer.update()
         origin_to_base_center(ob)
         bpy.context.view_layer.update()
-        <span class="c"># Sit on floor after bake</span>
-        bpy.context.view_layer.update()
         wb = world_bbox(ob)
         ob.location.z -= wb[<span class="n">0</span>].z
         ob.rotation_euler.z = rot_z
@@ -647,60 +697,67 @@ <h2>Source</h2>
         sc.collection.objects.link(ob)
         <span class="k">return</span> ob
 
-    left = make_prop(<span class="s">&quot;TrapProp&quot;</span>, (-<span class="n">1.55</span>, <span class="n">0.0</span>, <span class="n">0.0</span>), rot_z=math.radians(<span class="n">12</span>))
-    right = make_prop(<span class="s">&quot;KeepProp&quot;</span>, (<span class="n">1.55</span>, <span class="n">0.0</span>, <span class="n">0.0</span>), rot_z=math.radians(-<span class="n">8</span>))
+    <span class="k">def</span> make_socket(name, world_loc, mat, parent=<span class="k">None</span>):
+        me = build_socket_mesh()
+        me.materials.append(mat)
+        ob = bpy.data.objects.new(name, me)
+        ob.location = world_loc
+        sc.collection.objects.link(ob)
+        bpy.context.view_layer.update()
+        <span class="k">if</span> parent <span class="k">is</span> <span class="k">not</span> <span class="k">None</span>:
+            parent_keep_world(ob, parent)
+            bpy.context.view_layer.update()
+        <span class="k">return</span> ob
+
+    left = make_prop(<span class="s">&quot;TrapProp&quot;</span>, (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>), rot_z=math.radians(<span class="n">25</span>))
+    right = make_prop(<span class="s">&quot;KeepProp&quot;</span>, (<span class="n">2.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>), rot_z=math.radians(-<span class="n">8</span>))
 
-    <span class="c"># Accessory intended world pose (front of each pedestal mid-height)</span>
     bpy.context.view_layer.update()
-    left_front = left.matrix_world @ Vector((<span class="n">0.0</span>, -<span class="n">0.48</span>, <span class="n">0.85</span>))
-    right_front = right.matrix_world @ Vector((<span class="n">0.0</span>, -<span class="n">0.48</span>, <span class="n">0.85</span>))
+    left_front = left.matrix_world @ Vector((<span class="n">0.0</span>, -<span class="n">0.52</span>, <span class="n">0.78</span>))
+    right_front = right.matrix_world @ Vector((<span class="n">0.0</span>, -<span class="n">0.52</span>, <span class="n">0.78</span>))
 
-    trap_acc = make_acc(<span class="s">&quot;TrapAcc&quot;</span>, left_front, trap_m)
-    keep_acc = make_acc(<span class="s">&quot;KeepAcc&quot;</span>, right_front, acc_m)
-    trap_acc.scale = (<span class="n">1.8</span>, <span class="n">1.8</span>, <span class="n">1.8</span>)
-    keep_acc.scale = (<span class="n">1.8</span>, <span class="n">1.8</span>, <span class="n">1.8</span>)
-    bpy.context.view_layer.update()
+    make_socket(<span class="s">&quot;TrapSocket&quot;</span>, left_front, sock_empty_m, parent=left)
+    make_socket(<span class="s">&quot;KeepSocket&quot;</span>, right_front, sock_m, parent=right)
 
-    <span class="c"># Ghost at the intended pose on the TRAP side — the &quot;where it should stay&quot;</span>
-    ghost_m = make_material(
-        <span class="s">&quot;Ghost&quot;</span>, (<span class="n">0.7</span>, <span class="n">0.75</span>, <span class="n">0.8</span>), rough=<span class="n">0.6</span>, metallic=<span class="n">0.0</span>,
-        emit=(<span class="n">0.5</span>, <span class="n">0.55</span>, <span class="n">0.6</span>), estr=<span class="n">0.35</span>,
-    )
-    ghost = make_acc(<span class="s">&quot;ExpectedGhost&quot;</span>, left_front, ghost_m)
-    ghost.scale = (<span class="n">1.8</span>, <span class="n">1.8</span>, <span class="n">1.8</span>)
-    <span class="c"># slight transparency via alpha isn&#x27;t reliable in EEVEE without setup;</span>
-    <span class="c"># keep emissive pale so it reads as &quot;expected seat&quot;</span>
-
-    <span class="c"># Left: bare parent after translating+yawing parent → accessory teleports</span>
-    left.location += Vector((<span class="n">0.55</span>, <span class="n">0.35</span>, <span class="n">0.0</span>))
-    left.rotation_euler.z += math.radians(<span class="n">55</span>)
+    trap_acc = make_acc(<span class="s">&quot;TrapAcc&quot;</span>, left_front + Vector((<span class="n">0.0</span>, -<span class="n">0.08</span>, <span class="n">0.0</span>)), trap_m)
+    keep_acc = make_acc(<span class="s">&quot;KeepAcc&quot;</span>, right_front + Vector((<span class="n">0.0</span>, -<span class="n">0.08</span>, <span class="n">0.0</span>)), acc_m)
+    trap_acc.scale = (<span class="n">1.35</span>, <span class="n">1.35</span>, <span class="n">1.35</span>)
+    keep_acc.scale = (<span class="n">1.35</span>, <span class="n">1.35</span>, <span class="n">1.35</span>)
     bpy.context.view_layer.update()
+
     w_before = trap_acc.matrix_world.translation.copy()
     trap_acc.parent = left
     bpy.context.view_layer.update()
     jumped = (trap_acc.matrix_world.translation - w_before).length
-    print(<span class="s">f&quot;</span><span class="s">render_trap_jump=</span>{jumped:<span class="s">.4f</span>}<span class="s"> acc_at=</span>{tuple(round(c,<span class="n">3</span>) <span class="k">for</span> c <span class="k">in</span> trap_acc.matrix_world.translation)}<span class="s">&quot;</span>)
+    jumped_world = trap_acc.matrix_world.copy()
+    trap_acc.parent = <span class="k">None</span>
+    bpy.context.view_layer.update()
+    trap_acc.matrix_world = jumped_world
+    bpy.context.view_layer.update()
+    print(
+        <span class="s">f&quot;</span><span class="s">render_trap_jump=</span>{jumped:<span class="s">.4f</span>}<span class="s"> </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">acc_at=</span>{tuple(round(c, <span class="n">3</span>) <span class="k">for</span> c <span class="k">in</span> trap_acc.matrix_world.translation)}<span class="s">&quot;</span>
+    )
 
-    <span class="c"># Right: MPI keep-world (accessory stays on the front face)</span>
     parent_keep_world(keep_acc, right)
     bpy.context.view_layer.update()
 
-    <span class="c"># Origin markers at each prop&#x27;s object origin (base center after bake)</span>
+    <span class="c"># Origin markers at base — small, so they don&#x27;t compete with the accessory</span>
     origin_marker(sc, Vector(left.matrix_world.translation))
     origin_marker(sc, Vector(right.matrix_world.translation))
 
-    placard(sc, <span class="s">&quot;TRAP&quot;</span>, (-<span class="n">1.2</span>, -<span class="n">1.25</span>, <span class="n">0.02</span>), size=<span class="n">0.22</span>)
-    placard(sc, <span class="s">&quot;MPI KEEP&quot;</span>, (<span class="n">1.55</span>, -<span class="n">1.25</span>, <span class="n">0.02</span>), size=<span class="n">0.22</span>)
+    placard(sc, <span class="s">&quot;TRAP&quot;</span>, (<span class="n">0.0</span>, -<span class="n">1.05</span>, <span class="n">0.02</span>), size=<span class="n">0.16</span>)
+    placard(sc, <span class="s">&quot;MPI KEEP&quot;</span>, (<span class="n">2.0</span>, -<span class="n">1.05</span>, <span class="n">0.02</span>), size=<span class="n">0.16</span>)
 
     build_studio(sc)
 
     cam_data = bpy.data.cameras.new(<span class="s">&quot;Cam&quot;</span>)
-    cam_data.lens = <span class="n">38.0</span>
+    cam_data.lens = <span class="n">42.0</span>
     cam = bpy.data.objects.new(<span class="s">&quot;Cam&quot;</span>, cam_data)
-    cam.location = (<span class="n">0.15</span>, -<span class="n">7.2</span>, <span class="n">2.15</span>)
+    cam.location = (<span class="n">0.95</span>, -<span class="n">5.6</span>, <span class="n">1.55</span>)
     sc.collection.objects.link(cam)
     aim = bpy.data.objects.new(<span class="s">&quot;Aim&quot;</span>, <span class="k">None</span>)
-    aim.location = (<span class="n">0.15</span>, <span class="n">0.0</span>, <span class="n">0.9</span>)
+    aim.location = (<span class="n">0.95</span>, <span class="n">0.0</span>, <span class="n">0.72</span>)
     sc.collection.objects.link(aim)
     tr = cam.constraints.new(<span class="s">&quot;TRACK_TO&quot;</span>)
     tr.target = aim
diff --git a/examples/gallery.json b/examples/gallery.json
index cfd54fd..ee48e21 100644
--- a/examples/gallery.json
+++ b/examples/gallery.json
@@ -423,8 +423,8 @@
     {
       "name": "mesh-hygiene-audit",
       "dir": "examples/mesh-hygiene-audit",
-      "teaches": "Engine-ingest mesh hygiene as executable topology checks on a stepped street electrical pedestal (plinth, cabinet, drip cap). Gates: no ngons, no loose verts, every edge borders exactly 2 faces, no zero-area faces (min_area printed), positive signed volume, Euler V-E+F==2 (24/44/22, volume 0.989248). Dual-panel dirty vs clean still marks defects.",
-      "witnessesFix": "AI pipelines that skip topology gates ship ngons, loose verts, open boundaries, inverted winding, or non-sphere Euler into engine ingest. Injecting one defect class at a time exits non-zero (ngon=3, loose=4, boundary=5, zero-area=6, flip=7); the clean solid recovers hygiene_ok on both 4.5.11 and 5.1.2.",
+      "teaches": "Engine-ingest mesh hygiene on an octagonal street valve: no ngons, no loose verts, manifold edges, no zero-area faces, positive signed volume, Euler V-E+F==2. Dual-panel still shows a through-hole and loose-vert bead derived from live mesh incidence — same brass on both so color alone cannot carry the proof.",
+      "witnessesFix": "Pipelines that skip topology gates ship open boundaries, loose verts, or non-sphere Euler into engine ingest. The still makes the boundary hole and loose vert readable; ngon / zero-area / full winding invert remain check-only.",
       "hero": "docs/gallery/assets/mesh-hygiene-audit-hero.webp",
       "preview": "examples/mesh-hygiene-audit/preview.webp",
       "tags": [
@@ -436,8 +436,8 @@
     {
       "name": "prop-origin-transform",
       "dir": "examples/prop-origin-transform",
-      "teaches": "Street pedestal origin-to-base-center + data-API scale apply + matrix_parent_inverse for a bolted accessory. After bake: scale exactly (1,1,1), local min.z==0, world AABB delta 0. Bare parent jumps the accessory (~0.43 m); MPI restores world location (~3e-8). view_layer.update() before reading matrix_world.",
-      "witnessesFix": "AI code parents with child.parent = parent alone (accessory teleports), skips view_layer.update() before matrix_world, or leaves non-uniform scale / centered origin for engine ingest. Skipping apply, origin bake, or MPI each fails a closed-form gate.",
+      "teaches": "Street pedestal origin-to-base-center + data-API scale apply + matrix_parent_inverse for a flanged conduit accessory. After bake: scale (1,1,1), local min.z==0, world AABB unchanged. Bare parent jumps the accessory off an empty mount socket; MPI keeps it seated.",
+      "witnessesFix": "Bare child.parent = parent teleports accessories off their mounts; skipping view_layer.update() before matrix_world, or leaving non-uniform scale / centered origin, breaks engine ingest placement.",
       "hero": "docs/gallery/assets/prop-origin-transform-hero.webp",
       "preview": "examples/prop-origin-transform/preview.webp",
       "tags": [
diff --git a/examples/mesh-hygiene-audit/README.md b/examples/mesh-hygiene-audit/README.md
index 13325b6..9f763d2 100644
--- a/examples/mesh-hygiene-audit/README.md
+++ b/examples/mesh-hygiene-audit/README.md
@@ -1,7 +1,6 @@
 # Mesh Hygiene Audit
 
-A runnable example that builds a fabricated street electrical pedestal —
-stepped plinth, cabinet waist, drip-cap overhang — and runs the
+A runnable example that builds an octagonal street valve body and runs the
 **engine-ingest mesh hygiene checklist** as executable topology checks,
 following [`mesh-editing-and-bmesh`](../../skills/mesh-editing-and-bmesh/SKILL.md).
 
@@ -14,9 +13,7 @@ pipeline runs on the *render* mesh before hull / LOD / export.
 
 **Scope:** this witnesses the bpy-level contract a prop pipeline relies on
 (tris+quads, no loose verts, manifold edges, no zero-area faces, outward
-winding, Euler 2 for a closed solid). It is not an engine exporter and does
-not produce a shippable engine asset — it proves the topology properties
-such an asset must have.
+winding, Euler 2 for a closed solid). It is not an engine exporter.
 
 **What it witnesses:** every gate is derived from mesh combinatorics or the
 divergence-theorem volume — never from a prior-run capture:
@@ -27,7 +24,7 @@ divergence-theorem volume — never from a prior-run capture:
 - **No zero-area faces.** Face area > 1e-10; prints measured `min_area`.
 - **Outward winding.** Positive signed volume (divergence theorem).
 - **Euler sphere.** `V − E + F == 2` for the clean closed manifold
-  (measured: verts=24 edges=44 faces=22, volume≈0.989248).
+  (measured: verts=66 edges=136 faces=72, volume≈0.652001, min_area≈1.146e-02).
 
 **What each check catches on failure:** loose vert injected (exit 4);
 face deleted → boundary edges (exit 5); edge dissolved → ngon (exit 3);
@@ -35,24 +32,25 @@ all faces flipped → signed volume negated (exit 7); face collapsed →
 zero-area (exit 6).
 
 **Version witness:** output is byte-identical on Blender 4.5.11 LTS and
-5.1.2 — same counts, same volume, same `min_area`. The bmesh edge/face
-incidence and polygon vertex-count APIs are stable across the pair.
+5.1.2 — same counts, same volume, same `min_area`.
 
-The render is a dual panel: left **DIRTY** (boundary hole + loose-vert bead,
-emissive hazard + wireframe) vs right **CLEAN** manifold. Failure = identical
-panels or missing defect cues.
+**Render as proof:** dual panel, same brass on both. DIRTY stages a
+camera-facing through-hole (boundary edges) plus a loose vert; emissive
+beads/edge tubes are built from the live mesh incidence the check uses —
+not decorative paint. CLEAN is the intact manifold. A warm card behind the
+hole makes the void readable against the backdrop.
+
+**Not depicted in the still (check-proven only):** ngon dissolve, zero-area
+collapse, and full-mesh winding invert — they do not read as geometry at
+thumbnail scale without faking annotation.
 
 ## Run
 
 ```bash
-# Cheap correctness check (no render) — the CI check:
 blender --background --python mesh_hygiene_audit.py --
-
-# Also render a still (EEVEE on a GPU host; use --engine cycles on GPU-less hosts):
 blender --background --python mesh_hygiene_audit.py -- --output hygiene.png
 blender --background --python mesh_hygiene_audit.py -- --output hygiene.png --engine cycles
 ```
 
-It exits non-zero on failure (ngons, loose verts, non-manifold edges,
-zero-area faces, inverted winding, or Euler ≠ 2). The `blender-smoke`
-workflow runs the check on Blender 4.5 LTS and 5.1.
+Exits non-zero on failure. The `blender-smoke` workflow runs the check on
+Blender 4.5 LTS and 5.1.
diff --git a/examples/mesh-hygiene-audit/mesh_hygiene_audit.py b/examples/mesh-hygiene-audit/mesh_hygiene_audit.py
index a298d95..b8a64ff 100644
--- a/examples/mesh-hygiene-audit/mesh_hygiene_audit.py
+++ b/examples/mesh-hygiene-audit/mesh_hygiene_audit.py
@@ -65,43 +65,54 @@ def make_material(name, rgb, rough=0.45, metallic=0.35, emit=None, estr=0.0):
 
 
 def build_utility_pedestal():
-    """Single closed manifold: street electrical pedestal (fabricated panels).
+    """Backward-compat alias — subject is now a street valve body."""
+    return build_street_valve()
 
-    Explicit quad ring-stack — flared plinth, cabinet waist, drip-cap flare —
-    so the solid stays quads-only with every edge bordering exactly two faces
-    and Euler V-E+F == 2. Not a beveled cube: the silhouette steps are the
-    authored panels a prop pipeline would audit before ingest.
+
+def build_street_valve():
+    """Single closed manifold: octagonal street valve body (not a box pedestal).
+
+    Explicit quad ring-stack with 8-sided flanges + stem so the solid stays
+    quads-only, every edge borders exactly two faces, and Euler V-E+F == 2.
+    Differentiated from prop-origin-transform's rectangular pedestal silhouette.
     """
-    # (half_x, half_y, z) rings bottom → top
+    # (radius, z) rings bottom → top; each ring is a regular octagon
+    n = 8
     rings = [
-        (0.58, 0.48, 0.00),  # plinth base
-        (0.58, 0.48, 0.18),  # plinth top
-        (0.45, 0.35, 0.18),  # cabinet base (inset step)
-        (0.45, 0.35, 1.30),  # cabinet top
-        (0.52, 0.40, 1.30),  # drip-cap overhang
-        (0.52, 0.40, 1.40),  # drip-cap top
+        (0.62, 0.00),  # base flange
+        (0.62, 0.14),
+        (0.40, 0.14),  # body inset
+        (0.40, 0.95),
+        (0.55, 0.95),  # top flange
+        (0.55, 1.08),
+        (0.18, 1.08),  # stem
+        (0.18, 1.32),
     ]
 
-    me = bpy.data.meshes.new("UtilityPedestal")
+    me = bpy.data.meshes.new("StreetValve")
     bm = bmesh.new()
     try:
         ring_verts = []
-        for hx, hy, z in rings:
-            ring_verts.append([
-                bm.verts.new((-hx, -hy, z)),
-                bm.verts.new((hx, -hy, z)),
-                bm.verts.new((hx, hy, z)),
-                bm.verts.new((-hx, hy, z)),
-            ])
+        for r, z in rings:
+            ring = []
+            for i in range(n):
+                a = 2.0 * math.pi * i / n + math.pi / n  # flat-to-camera bias
+                ring.append(bm.verts.new((r * math.cos(a), r * math.sin(a), z)))
+            ring_verts.append(ring)
         for i in range(len(ring_verts) - 1):
             a, b = ring_verts[i], ring_verts[i + 1]
-            for k in range(4):
-                n = (k + 1) % 4
-                bm.faces.new((a[k], a[n], b[n], b[k]))
-        bot = ring_verts[0]
-        bm.faces.new((bot[0], bot[3], bot[2], bot[1]))
-        top = ring_verts[-1]
-        bm.faces.new((top[0], top[1], top[2], top[3]))
+            for k in range(n):
+                kn = (k + 1) % n
+                bm.faces.new((a[k], a[kn], b[kn], b[k]))
+        bot, top = ring_verts[0], ring_verts[-1]
+        # fan caps as quads via center verts would add poles; use triangle fan
+        # from a center → tris only on caps (still <=4). Prefer center poles.
+        bot_c = bm.verts.new((0.0, 0.0, rings[0][1]))
+        top_c = bm.verts.new((0.0, 0.0, rings[-1][1]))
+        for k in range(n):
+            kn = (k + 1) % n
+            bm.faces.new((bot_c, bot[kn], bot[k]))  # outward -Z
+            bm.faces.new((top_c, top[k], top[kn]))  # outward +Z
 
         bmesh.ops.recalc_face_normals(bm, faces=bm.faces)
         tmp = bpy.data.meshes.new("_tmp_vol")
@@ -122,11 +133,12 @@ def build_utility_pedestal():
     finally:
         bm.free()
 
-    mat = make_material("PedestalSteel", (0.18, 0.42, 0.38), rough=0.42, metallic=0.55)
+    # Brass / copper — distinct from prop-origin teal pedestal
+    mat = make_material("ValveBrass", (0.55, 0.38, 0.14), rough=0.38, metallic=0.85)
     me.materials.append(mat)
     for p in me.polygons:
-        p.use_smooth = False
-    ob = bpy.data.objects.new("UtilityPedestal", me)
+        p.use_smooth = abs(p.normal.z) < 0.85
+    ob = bpy.data.objects.new("StreetValve", me)
     bpy.context.collection.objects.link(ob)
     return ob
 
@@ -232,14 +244,20 @@ def inject_defect(me, kind):
             # next to the subject (not halfway to the clean panel).
             bm.verts.new((0.0, -0.55, 0.85))
         elif kind == "boundary":
-            # Prefer a large side face so the hole reads in the dual-panel still.
+            # Prefer a large camera-facing (-Y) face so the hole reads through
+            # to the lit backdrop in the dual-panel still.
             faces = sorted(bm.faces, key=lambda f: -f.calc_area())
             target = None
             for f in faces:
                 n = f.normal
-                if abs(n.x) > 0.7:  # side panel
+                if n.y < -0.55:
                     target = f
                     break
+            if target is None:
+                for f in faces:
+                    if abs(f.normal.x) > 0.7:
+                        target = f
+                        break
             if target is None and faces:
                 target = faces[0]
             if target is not None:
@@ -317,90 +335,121 @@ def _duplicate_mesh_obj(sc, src, name, loc):
     return ob
 
 
-def mark_defects(ob):
-    """Emissive hazard material + wireframe so defects read in-frame."""
-    mat = make_material(
-        "Hazard", (0.75, 0.18, 0.08), rough=0.5, metallic=0.25,
-        emit=(1.0, 0.3, 0.05), estr=0.85,
-    )
-    wire_mat = make_material(
-        "HazardWire", (1.0, 0.35, 0.05), rough=0.4, metallic=0.0,
-        emit=(1.0, 0.4, 0.05), estr=2.0,
-    )
-    ob.data.materials.clear()
-    ob.data.materials.append(mat)
-    ob.data.materials.append(wire_mat)
-    wire = bpy.data.objects.new(ob.name + "Wire", ob.data)
-    mod = wire.modifiers.new("Wire", "WIREFRAME")
-    mod.thickness = 0.012
-    mod.material_offset = 1
-    bpy.context.scene.collection.objects.link(wire)
-    wire.location = ob.location
+def _inject_through_hole(me):
+    """Render staging: delete a front/back body-face pair so the void reads.
 
+    Produces boundary edges (same gate class as inject_defect('boundary')).
+    Does not change the check path — only the dual-panel still.
+    """
     bm = bmesh.new()
     try:
-        bm.from_mesh(ob.data)
-        coords = [v.co.copy() for v in bm.verts if len(v.link_edges) == 0]
+        bm.from_mesh(me)
+        bm.faces.ensure_lookup_table()
+        # Prefer mid-height body faces (not flanges/caps)
+        body = [
+            f for f in bm.faces
+            if abs(f.normal.z) < 0.35 and 0.2 < f.calc_center_median().z < 0.9
+        ]
+        if not body:
+            body = list(bm.faces)
+        front = max(body, key=lambda f: -f.normal.y * f.calc_area())
+        back = max(body, key=lambda f: f.normal.y * f.calc_area())
+        doomed = [front] if front is back else [front, back]
+        bmesh.ops.delete(bm, geom=doomed, context="FACES_ONLY")
+        bm.to_mesh(me)
+        me.update()
     finally:
         bm.free()
+
+
+def _defect_geometry(me):
+    """Loose-vert coords and boundary edge pairs — same incidence as audit()."""
+    bm = bmesh.new()
+    try:
+        bm.from_mesh(me)
+        bm.verts.ensure_lookup_table()
+        bm.edges.ensure_lookup_table()
+        loose = [v.co.copy() for v in bm.verts if len(v.link_edges) == 0]
+        boundary = [
+            (e.verts[0].co.copy(), e.verts[1].co.copy())
+            for e in bm.edges if len(e.link_faces) == 1
+        ]
+    finally:
+        bm.free()
+    return loose, boundary
+
+
+def mark_defects_from_audit(ob):
+    """Overlay markers from live mesh defects — not decorative paint.
+
+    Loose verts → emissive beads at measured local coords.
+    Boundary edges → emissive tubes along those edge endpoints.
+    Body keeps the same brass as CLEAN so the difference is topological.
+    """
+    sc = bpy.context.scene
+    loose, boundary = _defect_geometry(ob.data)
+    metrics = audit(ob.data)
+    print(
+        f"render_defects loose={metrics['loose']} boundary_edges={metrics['boundary']} "
+        f"ngons={metrics['ngons']} zero_area={metrics['zero_area']}"
+    )
+
+    brass = make_material("DirtyBrass", (0.55, 0.38, 0.14), rough=0.38, metallic=0.85)
+    ob.data.materials.clear()
+    ob.data.materials.append(brass)
+
     bead_mat = make_material(
-        "LooseBead", (1.0, 0.9, 0.2), rough=0.3, metallic=0.0,
-        emit=(1.0, 0.85, 0.1), estr=2.5,
+        "LooseBead", (1.0, 0.85, 0.15), rough=0.3, metallic=0.0,
+        emit=(1.0, 0.9, 0.2), estr=3.0,
     )
-    sc = bpy.context.scene
-    for i, co in enumerate(coords):
-        sme = bpy.data.meshes.new(f"Bead{i}")
+    for i, co in enumerate(loose):
+        sme = bpy.data.meshes.new(f"LooseBead{i}")
         sbm = bmesh.new()
         try:
-            bmesh.ops.create_uvsphere(sbm, u_segments=8, v_segments=6, radius=0.07)
+            bmesh.ops.create_uvsphere(sbm, u_segments=10, v_segments=8, radius=0.055)
             sbm.to_mesh(sme)
         finally:
             sbm.free()
         sme.materials.append(bead_mat)
-        sob = bpy.data.objects.new(f"Bead{i}", sme)
+        sob = bpy.data.objects.new(f"LooseBead{i}", sme)
         sob.location = Vector(ob.location) + co
         sc.collection.objects.link(sob)
 
-
-def add_door_dressing(sc, parent_loc, suffix):
-    """Non-audited door plaque + bolts — silhouette only, not in the check mesh."""
-    door_m = make_material(f"Door{suffix}", (0.16, 0.20, 0.18), rough=0.4, metallic=0.65)
-    bolt_m = make_material(f"Bolt{suffix}", (0.55, 0.45, 0.22), rough=0.35, metallic=0.85)
-    # door plaque
-    me = bpy.data.meshes.new(f"Door{suffix}")
-    bm = bmesh.new()
-    try:
-        bmesh.ops.create_cube(bm, size=1.0)
-        bmesh.ops.transform(
-            bm, matrix=Matrix.Diagonal((0.55, 0.03, 0.85, 1.0)), verts=bm.verts,
-        )
-        bm.to_mesh(me)
-    finally:
-        bm.free()
-    me.materials.append(door_m)
-    door = bpy.data.objects.new(f"Door{suffix}", me)
-    door.location = (parent_loc[0], parent_loc[1] - 0.365, parent_loc[2] + 0.75)
-    sc.collection.objects.link(door)
-    for x, z in ((-0.18, 0.45), (0.18, 0.45), (-0.18, 1.05), (0.18, 1.05)):
-        bme = bpy.data.meshes.new(f"Bolt{suffix}_{x}_{z}")
-        bbm = bmesh.new()
+    edge_mat = make_material(
+        "BoundaryEdge", (1.0, 0.25, 0.05), rough=0.35, metallic=0.0,
+        emit=(1.0, 0.35, 0.05), estr=2.8,
+    )
+    for i, (a, b) in enumerate(boundary):
+        mid = (a + b) * 0.5
+        direction = b - a
+        length = direction.length
+        if length < 1e-8:
+            continue
+        eme = bpy.data.meshes.new(f"Bnd{i}")
+        ebm = bmesh.new()
         try:
             bmesh.ops.create_cone(
-                bbm, cap_ends=True, segments=10, radius1=0.03, radius2=0.03, depth=0.04,
+                ebm, cap_ends=True, segments=6,
+                radius1=0.018, radius2=0.018, depth=length,
             )
-            bbm.to_mesh(bme)
+            ebm.to_mesh(eme)
         finally:
-            bbm.free()
-        bme.materials.append(bolt_m)
-        bob = bpy.data.objects.new(f"Bolt{suffix}_{x}_{z}", bme)
-        bob.location = (parent_loc[0] + x, parent_loc[1] - 0.39, parent_loc[2] + z)
-        sc.collection.objects.link(bob)
+            ebm.free()
+        eme.materials.append(edge_mat)
+        eob = bpy.data.objects.new(f"Bnd{i}", eme)
+        eob.location = Vector(ob.location) + mid
+        quat = direction.normalized().to_track_quat("Z", "Y")
+        eob.rotation_mode = "QUATERNION"
+        eob.rotation_quaternion = quat
+        sc.collection.objects.link(eob)
+
+    return metrics
 
 
-def placard(sc, text, loc):
+def placard(sc, text, loc, size=0.18):
     cu = bpy.data.curves.new(text, "FONT")
     cu.body = text
-    cu.size = 0.22
+    cu.size = size
     cu.align_x = "CENTER"
     ob = bpy.data.objects.new(text, cu)
     ob.location = loc
@@ -411,36 +460,67 @@ def placard(sc, text, loc):
 
 
 def render_still(clean_ob, path, engine):
-    """Dual-panel dirty (left) vs clean (right) — contract at a glance."""
+    """Dual-panel dirty vs clean — topology defects visible in the pixels.
+
+    DIRTY: camera-facing boundary hole + loose vert; overlays from audit data.
+    CLEAN: intact manifold. Same brass on both so color alone cannot carry proof.
+
+    Ngons / zero-area / full winding invert are check-proven but not staged
+    (see README) — they do not read as geometry at thumbnail scale without faking.
+    """
     sc = bpy.context.scene
     clean_ob.hide_render = True
     clean_ob.hide_viewport = True
 
-    left = _duplicate_mesh_obj(sc, clean_ob, "Dirty", (-1.35, 0.0, 0.0))
-    inject_defect(left.data, "boundary")
+    left = _duplicate_mesh_obj(sc, clean_ob, "Dirty", (-1.15, 0.0, 0.0))
+    left.rotation_euler.z = math.radians(22.5)
+    bpy.context.view_layer.update()
+    _inject_through_hole(left.data)
     inject_defect(left.data, "loose")
-    mark_defects(left)
-    add_door_dressing(sc, (-1.35, 0.0, 0.0), "Dirty")
+    mark_defects_from_audit(left)
 
-    right = _duplicate_mesh_obj(sc, clean_ob, "Clean", (1.35, 0.0, 0.0))
+    right = _duplicate_mesh_obj(sc, clean_ob, "Clean", (1.15, 0.0, 0.0))
+    right.rotation_euler.z = math.radians(-12)
     right.data.materials.clear()
     right.data.materials.append(
-        make_material("CleanSteel", (0.18, 0.42, 0.38), rough=0.42, metallic=0.55)
+        make_material("CleanBrass", (0.55, 0.38, 0.14), rough=0.38, metallic=0.85)
     )
-    add_door_dressing(sc, (1.35, 0.0, 0.0), "Clean")
+    for p in right.data.polygons:
+        p.use_smooth = abs(p.normal.z) < 0.85
 
-    placard(sc, "DIRTY", (-1.35, -0.85, 0.02))
-    placard(sc, "CLEAN", (1.35, -0.85, 0.02))
+    placard(sc, "DIRTY", (-1.15, -1.0, 0.02), size=0.15)
+    placard(sc, "CLEAN", (1.15, -1.0, 0.02), size=0.15)
 
     build_studio(sc)
+    # Lit card behind DIRTY so the through-hole voids read against warm light
+    card_me = bpy.data.meshes.new("HoleCard")
+    cbm = bmesh.new()
+    try:
+        bmesh.ops.create_grid(cbm, x_segments=1, y_segments=1, size=1.2)
+        cbm.to_mesh(card_me)
+    finally:
+        cbm.free()
+    card_mat = make_material(
+        "HoleCard", (1.0, 0.55, 0.25), rough=0.9, metallic=0.0,
+        emit=(1.0, 0.55, 0.2), estr=1.8,
+    )
+    card_me.materials.append(card_mat)
+    card = bpy.data.objects.new("HoleCard", card_me)
+    card.location = (-1.15, 1.4, 0.65)
+    card.rotation_euler = (math.radians(90), 0.0, 0.0)
+    sc.collection.objects.link(card)
+    for ob in sc.objects:
+        if ob.type == "LIGHT" and ob.name == "Wedge":
+            ob.data.energy = 580.0
+            ob.location = (0.0, 6.5, 3.5)
 
     cam_data = bpy.data.cameras.new("Cam")
-    cam_data.lens = 48.0
+    cam_data.lens = 50.0
     cam = bpy.data.objects.new("Cam", cam_data)
-    cam.location = (0.55, -5.0, 1.55)
+    cam.location = (0.1, -5.6, 1.5)
     sc.collection.objects.link(cam)
     aim = bpy.data.objects.new("Aim", None)
-    aim.location = (0.0, 0.0, 0.70)
+    aim.location = (0.0, 0.0, 0.62)
     sc.collection.objects.link(aim)
     tr = cam.constraints.new("TRACK_TO")
     tr.target = aim
@@ -469,7 +549,7 @@ def render_still(clean_ob, path, engine):
 
 def build_scene():
     bpy.ops.wm.read_factory_settings(use_empty=True)
-    return bpy.context.scene, build_utility_pedestal()
+    return bpy.context.scene, build_street_valve()
 
 
 def main():
diff --git a/examples/mesh-hygiene-audit/preview.webp b/examples/mesh-hygiene-audit/preview.webp
index 9315936..f9f1538 100644
Binary files a/examples/mesh-hygiene-audit/preview.webp and b/examples/mesh-hygiene-audit/preview.webp differ
diff --git a/examples/prop-origin-transform/README.md b/examples/prop-origin-transform/README.md
index 5536794..e5875b9 100644
--- a/examples/prop-origin-transform/README.md
+++ b/examples/prop-origin-transform/README.md
@@ -36,9 +36,10 @@ MPI leaves the accessory teleported.
 
 **Version witness:** byte-identical numbers on Blender 4.5.11 LTS and 5.1.2.
 
-The render is a dual panel: left **TRAP** (bare parent — accessory teleports,
-hazard material) vs right **MPI KEEP** (accessory stays put), with emissive
-origin markers at each pedestal's base.
+The render is a dual panel: left **TRAP** (bare parent — flanged conduit
+teleports off an empty mount socket, hazard material) vs right **MPI KEEP**
+(flange seated in the socket), with emissive origin markers at each pedestal's
+base. Check closed forms are unchanged; the flange/socket are render form only.
 
 ## Run
 
diff --git a/examples/prop-origin-transform/preview.webp b/examples/prop-origin-transform/preview.webp
index 532c899..bc1066e 100644
Binary files a/examples/prop-origin-transform/preview.webp and b/examples/prop-origin-transform/preview.webp differ
diff --git a/examples/prop-origin-transform/prop_origin_transform.py b/examples/prop-origin-transform/prop_origin_transform.py
index 4470ec8..5609994 100644
--- a/examples/prop-origin-transform/prop_origin_transform.py
+++ b/examples/prop-origin-transform/prop_origin_transform.py
@@ -110,17 +110,64 @@ def build_pedestal_mesh():
 
 
 def build_accessory_mesh():
-    """Small conduit elbow — bolted accessory for the MPI trap."""
+    """Flanged conduit stub — reads as a bolted part, not a stray cylinder."""
     me = bpy.data.meshes.new("Conduit")
     bm = bmesh.new()
     try:
+        # Barrel along +Y (away from prop face when mounted)
         bmesh.ops.create_cone(
-            bm, cap_ends=True, segments=12, radius1=0.07, radius2=0.07, depth=0.35,
+            bm, cap_ends=True, segments=14, radius1=0.08, radius2=0.08, depth=0.42,
         )
         bmesh.ops.rotate(
             bm, verts=bm.verts, cent=(0, 0, 0),
             matrix=Matrix.Rotation(math.radians(90), 4, "X"),
         )
+        bmesh.ops.translate(bm, vec=(0.0, -0.21, 0.0), verts=bm.verts)
+        # Mounting flange at the prop-facing end
+        ret = bmesh.ops.create_cone(
+            bm, cap_ends=True, segments=16, radius1=0.16, radius2=0.16, depth=0.04,
+        )
+        bmesh.ops.rotate(
+            bm, verts=ret["verts"], cent=(0, 0, 0),
+            matrix=Matrix.Rotation(math.radians(90), 4, "X"),
+        )
+        bmesh.ops.translate(bm, vec=(0.0, 0.02, 0.0), verts=ret["verts"])
+        # Four bolt heads on the flange
+        for ang in (45, 135, 225, 315):
+            rad = math.radians(ang)
+            bx, bz = 0.11 * math.cos(rad), 0.11 * math.sin(rad)
+            br = bmesh.ops.create_cone(
+                bm, cap_ends=True, segments=8, radius1=0.025, radius2=0.025, depth=0.03,
+            )
+            bmesh.ops.rotate(
+                bm, verts=br["verts"], cent=(0, 0, 0),
+                matrix=Matrix.Rotation(math.radians(90), 4, "X"),
+            )
+            bmesh.ops.translate(bm, vec=(bx, 0.05, bz), verts=br["verts"])
+        bm.to_mesh(me)
+    finally:
+        bm.free()
+    return me
+
+
+def build_socket_mesh():
+    """Empty mount collar left on the prop — the seat the accessory departed."""
+    me = bpy.data.meshes.new("Socket")
+    bm = bmesh.new()
+    try:
+        # Outer ring
+        bmesh.ops.create_cone(
+            bm, cap_ends=True, segments=20, radius1=0.18, radius2=0.18, depth=0.05,
+        )
+        # Punch a visual recess by adding an inset darker disk slightly proud
+        inner = bmesh.ops.create_cone(
+            bm, cap_ends=True, segments=16, radius1=0.09, radius2=0.09, depth=0.02,
+        )
+        bmesh.ops.translate(bm, vec=(0.0, 0.0, 0.02), verts=inner["verts"])
+        bmesh.ops.rotate(
+            bm, verts=bm.verts, cent=(0, 0, 0),
+            matrix=Matrix.Rotation(math.radians(90), 4, "X"),
+        )
         bm.to_mesh(me)
     finally:
         bm.free()
@@ -401,15 +448,20 @@ def light(name, loc, energy, size, col, rot):
 
 def render_still(path, engine):
     """Dual panel: bare-parent TRAP (left) vs MPI KEEP (right) + origin at base."""
-    # Fresh scene for the still so check mutations don't poison framing
     bpy.ops.wm.read_factory_settings(use_empty=True)
     sc = bpy.context.scene
 
-    body_m = make_material("BodyR", (0.18, 0.42, 0.38), rough=0.42, metallic=0.55)
-    acc_m = make_material("AccR", (0.55, 0.45, 0.22), rough=0.35, metallic=0.8)
+    # Teal pedestal — distinct from mesh-hygiene brass valve
+    body_m = make_material("BodyR", (0.14, 0.48, 0.42), rough=0.4, metallic=0.55)
+    acc_m = make_material("AccR", (0.62, 0.48, 0.18), rough=0.35, metallic=0.85)
     trap_m = make_material(
-        "TrapAcc", (0.9, 0.2, 0.1), rough=0.4, metallic=0.3,
-        emit=(1.0, 0.25, 0.05), estr=1.0,
+        "TrapAcc", (0.95, 0.28, 0.08), rough=0.4, metallic=0.35,
+        emit=(1.0, 0.3, 0.05), estr=1.1,
+    )
+    sock_m = make_material("Socket", (0.12, 0.14, 0.15), rough=0.55, metallic=0.4)
+    sock_empty_m = make_material(
+        "SocketEmpty", (0.35, 0.55, 0.75), rough=0.45, metallic=0.2,
+        emit=(0.3, 0.5, 0.75), estr=0.6,
     )
 
     def make_prop(name, loc, rot_z=0.0):
@@ -426,8 +478,6 @@ def make_prop(name, loc, rot_z=0.0):
         bpy.context.view_layer.update()
         origin_to_base_center(ob)
         bpy.context.view_layer.update()
-        # Sit on floor after bake
-        bpy.context.view_layer.update()
         wb = world_bbox(ob)
         ob.location.z -= wb[0].z
         ob.rotation_euler.z = rot_z
@@ -442,60 +492,67 @@ def make_acc(name, world_loc, mat):
         sc.collection.objects.link(ob)
         return ob
 
-    left = make_prop("TrapProp", (-1.55, 0.0, 0.0), rot_z=math.radians(12))
-    right = make_prop("KeepProp", (1.55, 0.0, 0.0), rot_z=math.radians(-8))
+    def make_socket(name, world_loc, mat, parent=None):
+        me = build_socket_mesh()
+        me.materials.append(mat)
+        ob = bpy.data.objects.new(name, me)
+        ob.location = world_loc
+        sc.collection.objects.link(ob)
+        bpy.context.view_layer.update()
+        if parent is not None:
+            parent_keep_world(ob, parent)
+            bpy.context.view_layer.update()
+        return ob
+
+    left = make_prop("TrapProp", (0.0, 0.0, 0.0), rot_z=math.radians(25))
+    right = make_prop("KeepProp", (2.0, 0.0, 0.0), rot_z=math.radians(-8))
 
-    # Accessory intended world pose (front of each pedestal mid-height)
     bpy.context.view_layer.update()
-    left_front = left.matrix_world @ Vector((0.0, -0.48, 0.85))
-    right_front = right.matrix_world @ Vector((0.0, -0.48, 0.85))
+    left_front = left.matrix_world @ Vector((0.0, -0.52, 0.78))
+    right_front = right.matrix_world @ Vector((0.0, -0.52, 0.78))
 
-    trap_acc = make_acc("TrapAcc", left_front, trap_m)
-    keep_acc = make_acc("KeepAcc", right_front, acc_m)
-    trap_acc.scale = (1.8, 1.8, 1.8)
-    keep_acc.scale = (1.8, 1.8, 1.8)
-    bpy.context.view_layer.update()
+    make_socket("TrapSocket", left_front, sock_empty_m, parent=left)
+    make_socket("KeepSocket", right_front, sock_m, parent=right)
 
-    # Ghost at the intended pose on the TRAP side — the "where it should stay"
-    ghost_m = make_material(
-        "Ghost", (0.7, 0.75, 0.8), rough=0.6, metallic=0.0,
-        emit=(0.5, 0.55, 0.6), estr=0.35,
-    )
-    ghost = make_acc("ExpectedGhost", left_front, ghost_m)
-    ghost.scale = (1.8, 1.8, 1.8)
-    # slight transparency via alpha isn't reliable in EEVEE without setup;
-    # keep emissive pale so it reads as "expected seat"
-
-    # Left: bare parent after translating+yawing parent → accessory teleports
-    left.location += Vector((0.55, 0.35, 0.0))
-    left.rotation_euler.z += math.radians(55)
+    trap_acc = make_acc("TrapAcc", left_front + Vector((0.0, -0.08, 0.0)), trap_m)
+    keep_acc = make_acc("KeepAcc", right_front + Vector((0.0, -0.08, 0.0)), acc_m)
+    trap_acc.scale = (1.35, 1.35, 1.35)
+    keep_acc.scale = (1.35, 1.35, 1.35)
     bpy.context.view_layer.update()
+
     w_before = trap_acc.matrix_world.translation.copy()
     trap_acc.parent = left
     bpy.context.view_layer.update()
     jumped = (trap_acc.matrix_world.translation - w_before).length
-    print(f"render_trap_jump={jumped:.4f} acc_at={tuple(round(c,3) for c in trap_acc.matrix_world.translation)}")
+    jumped_world = trap_acc.matrix_world.copy()
+    trap_acc.parent = None
+    bpy.context.view_layer.update()
+    trap_acc.matrix_world = jumped_world
+    bpy.context.view_layer.update()
+    print(
+        f"render_trap_jump={jumped:.4f} "
+        f"acc_at={tuple(round(c, 3) for c in trap_acc.matrix_world.translation)}"
+    )
 
-    # Right: MPI keep-world (accessory stays on the front face)
     parent_keep_world(keep_acc, right)
     bpy.context.view_layer.update()
 
-    # Origin markers at each prop's object origin (base center after bake)
+    # Origin markers at base — small, so they don't compete with the accessory
     origin_marker(sc, Vector(left.matrix_world.translation))
     origin_marker(sc, Vector(right.matrix_world.translation))
 
-    placard(sc, "TRAP", (-1.2, -1.25, 0.02), size=0.22)
-    placard(sc, "MPI KEEP", (1.55, -1.25, 0.02), size=0.22)
+    placard(sc, "TRAP", (0.0, -1.05, 0.02), size=0.16)
+    placard(sc, "MPI KEEP", (2.0, -1.05, 0.02), size=0.16)
 
     build_studio(sc)
 
     cam_data = bpy.data.cameras.new("Cam")
-    cam_data.lens = 38.0
+    cam_data.lens = 42.0
     cam = bpy.data.objects.new("Cam", cam_data)
-    cam.location = (0.15, -7.2, 2.15)
+    cam.location = (0.95, -5.6, 1.55)
     sc.collection.objects.link(cam)
     aim = bpy.data.objects.new("Aim", None)
-    aim.location = (0.15, 0.0, 0.9)
+    aim.location = (0.95, 0.0, 0.72)
     sc.collection.objects.link(aim)
     tr = cam.constraints.new("TRACK_TO")
     tr.target = aim