diff --git a/README.md b/README.md
index 0a57365e..db5f4bae 100644
--- a/README.md
+++ b/README.md
@@ -1010,7 +1010,7 @@ still: DIRTY through-hole + loose-vert bead vs CLEAN manifold (same brass).
 </tr>
 <tr>
 <td width="46%" valign="middle">
-<a href="examples/prop-origin-transform/"><img src="examples/prop-origin-transform/preview.webp" alt="Prop origin transform: dual-panel TRAP vs MPI KEEP street pedestals with margins all around — left bare-parent conduit accessory teleports off its dark mount well, right accessory stays seated, origin axes crossing on the floor under each base — proving scale apply, base origin, and matrix_parent_inverse" /></a>
+<a href="examples/prop-origin-transform/"><img src="examples/prop-origin-transform/preview.webp" alt="Prop origin transform: two green street utility pedestals, each centred in a floor pivot ring — left, the orange conduit elbow parented with matrix_parent_inverse stays bolted to its mount; right, bare child.parent = parent throws the elbow into the air beyond the slab while a glowing cyan outline marks its empty seat — proving scale apply, base origin, and matrix_parent_inverse" /></a>
 </td>
 <td valign="middle">
 
@@ -1019,7 +1019,7 @@ still: DIRTY through-hole + loose-vert bead vs CLEAN manifold (same brass).
 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 flanged conduit stays on its mount socket.
+`matrix_parent_inverse` so a flanged conduit elbow stays on its mount.
 Extends [`parent-inverse-orrery`](examples/parent-inverse-orrery/) without
 retreading orbits. Dual-panel still: TRAP (bare parent — empty socket +
 teleported flange) vs MPI KEEP.
diff --git a/docs/gallery/asset-sheets/prop-origin-transform.webp b/docs/gallery/asset-sheets/prop-origin-transform.webp
new file mode 100644
index 00000000..1cd83519
Binary files /dev/null and b/docs/gallery/asset-sheets/prop-origin-transform.webp differ
diff --git a/docs/gallery/assets/prop-origin-transform-hero.webp b/docs/gallery/assets/prop-origin-transform-hero.webp
index 1453bfe7..b207291a 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/prop-origin-transform-contact-sheet.webp b/docs/gallery/contact-sheets/prop-origin-transform-contact-sheet.webp
index 944ef82b..3709f112 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 c26ce7ee..8a3ed156 100644
--- a/docs/gallery/index.html
+++ b/docs/gallery/index.html
@@ -750,11 +750,11 @@ <h2><a href="mesh-hygiene-audit/">mesh-hygiene-audit</a></h2>
       </article>
       <article class="card" data-tags="transforms parenting game-pipeline">
         <a class="card-media" href="prop-origin-transform/" tabindex="-1" aria-hidden="true">
-          <img src="assets/prop-origin-transform-hero.webp" alt="Two teal pedestals labelled TRAP and MPI KEEP, origin axes crossing on the floor under each base: on the left a conduit fitting has jumped out of its socket, on the right it sits seated." loading="lazy" decoding="async" />
+          <img src="assets/prop-origin-transform-hero.webp" alt="Two green street utility pedestals in floor pivot rings: the left one keeps its orange conduit elbow bolted on, the right one&#x27;s elbow hangs in the air beside a glowing cyan outline of its seat." 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 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="teaches">Street pedestal origin-to-base-center + data-API scale apply + matrix_parent_inverse for a flanged conduit elbow. After bake: scale (1,1,1), local min.z==0, world AABB unchanged. Bare parent throws the elbow off its mount; 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 class="sr-only"> prop-origin-transform</span> <span aria-hidden="true">&rarr;</span></a>
         </div>
diff --git a/docs/gallery/prop-origin-transform/index.html b/docs/gallery/prop-origin-transform/index.html
index d110e3d7..f9259d03 100644
--- a/docs/gallery/prop-origin-transform/index.html
+++ b/docs/gallery/prop-origin-transform/index.html
@@ -4,25 +4,25 @@
   <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 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="description" content="Street pedestal origin-to-base-center + data-API scale apply + matrix_parent_inverse for a flanged conduit elbow. After bake: scale (1,1,1), local min.z==0, world AABB unchanged. Bare parent throws the elbow off its mount; 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 name="color-scheme" content="dark" />
   <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 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:description" content="Street pedestal origin-to-base-center + data-API scale apply + matrix_parent_inverse for a flanged conduit elbow. After bake: scale (1,1,1), local min.z==0, world AABB unchanged. Bare parent throws the elbow off its mount; 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 property="og:image:width" content="1280" />
   <meta property="og:image:height" content="720" />
-  <meta property="og:image:alt" content="Two teal pedestals labelled TRAP and MPI KEEP, origin axes crossing on the floor under each base: on the left a conduit fitting has jumped out of its socket, on the right it sits seated." />
+  <meta property="og:image:alt" content="Two green street utility pedestals in floor pivot rings: the left one keeps its orange conduit elbow bolted on, the right one&#x27;s elbow hangs in the air beside a glowing cyan outline of its seat." />
   <meta property="og:site_name" content="Blender Developer Tools" />
   <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 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:description" content="Street pedestal origin-to-base-center + data-API scale apply + matrix_parent_inverse for a flanged conduit elbow. After bake: scale (1,1,1), local min.z==0, world AABB unchanged. Bare parent throws the elbow off its mount; MPI keeps it seated." />
   <meta name="twitter:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/prop-origin-transform-hero.webp" />
-  <meta name="twitter:image:alt" content="Two teal pedestals labelled TRAP and MPI KEEP, origin axes crossing on the floor under each base: on the left a conduit fitting has jumped out of its socket, on the right it sits seated." />
+  <meta name="twitter:image:alt" content="Two green street utility pedestals in floor pivot rings: the left one keeps its orange conduit elbow bolted on, the right one&#x27;s elbow hangs in the air beside a glowing cyan outline of its seat." />
   <style>
     /* fonts are deployed by the landing build (docs/fonts/) */
     @font-face { font-family: 'Barlow Condensed'; font-weight: 600; font-display: swap;
@@ -265,11 +265,11 @@
   </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 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>Street pedestal origin-to-base-center + data-API scale apply + matrix_parent_inverse for a flanged conduit elbow. After bake: scale (1,1,1), local min.z==0, world AABB unchanged. Bare parent throws the elbow off its mount; MPI keeps it seated.</p>
   </header>
   <main id="main">
-    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: Two teal pedestals labelled TRAP and MPI KEEP, origin axes crossing on the floor under each base: on the left a conduit fitting has jumped out of its socket, on the right it sits seated.">
-      <img src="../assets/prop-origin-transform-hero.webp" alt="Two teal pedestals labelled TRAP and MPI KEEP, origin axes crossing on the floor under each base: on the left a conduit fitting has jumped out of its socket, on the right it sits seated." width="1280" height="720" />
+    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: Two green street utility pedestals in floor pivot rings: the left one keeps its orange conduit elbow bolted on, the right one&#x27;s elbow hangs in the air beside a glowing cyan outline of its seat.">
+      <img src="../assets/prop-origin-transform-hero.webp" alt="Two green street utility pedestals in floor pivot rings: the left one keeps its orange conduit elbow bolted on, the right one&#x27;s elbow hangs in the air beside a glowing cyan outline of its seat." 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> 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>
@@ -278,14 +278,15 @@ <h1>prop-origin-transform</h1>
       <button class="copy-btn" id="copyRun" type="button">Copy</button>
     </div>
     <section class="detail-section md">
-<p>A runnable example that builds a street utility pedestal with a bolted conduit accessory and proves the <strong>origin / scale-apply / MPI</strong> contract a prop pipeline relies on before engine ingest — following <a href="https://github.com/TMHSDigital/Blender-Developer-Tools/tree/main/skills/operators/SKILL.md"><code>operators</code></a> and the data-API parenting idiom from <a href="https://github.com/TMHSDigital/Blender-Developer-Tools/tree/main/examples/parent-inverse-orrery"><code>parent-inverse-orrery</code></a>.</p>
+<p>A runnable example that builds a street utility pedestal with a flanged conduit elbow and proves the <strong>origin / scale-apply / MPI</strong> contract a prop pipeline relies on before engine ingest — following <a href="https://github.com/TMHSDigital/Blender-Developer-Tools/tree/main/skills/operators/SKILL.md"><code>operators</code></a> and the data-API parenting idiom from <a href="https://github.com/TMHSDigital/Blender-Developer-Tools/tree/main/examples/parent-inverse-orrery"><code>parent-inverse-orrery</code></a>.</p>
 <p><strong>Pipeline arc neighbors:</strong> MPI + stale <code>matrix_world</code> in <a href="https://github.com/TMHSDigital/Blender-Developer-Tools/tree/main/examples/parent-inverse-orrery"><code>parent-inverse-orrery</code></a>, export origin sensitivity in <a href="https://github.com/TMHSDigital/Blender-Developer-Tools/tree/main/examples/gltf-export-roundtrip"><code>gltf-export-roundtrip</code></a>, collision bounds in <a href="https://github.com/TMHSDigital/Blender-Developer-Tools/tree/main/examples/collision-hull-proxy"><code>collision-hull-proxy</code></a>, and mesh hygiene in <a href="https://github.com/TMHSDigital/Blender-Developer-Tools/tree/main/examples/mesh-hygiene-audit"><code>mesh-hygiene-audit</code></a>. Origin at the base center with applied scale is what placement and physics ingest assume.</p>
 <p><strong>Scope:</strong> this witnesses the bpy-level contract a prop pipeline relies on (post-bake scale exactly <code>(1,1,1)</code>, local bbox <code>min.z == 0</code>, world bbox unchanged, MPI so a parented accessory does not teleport). It is not an engine exporter — it proves the transform properties such an asset must have.</p>
 <p><strong>What it witnesses:</strong></p>
-<ul><li><strong>Stale <code>matrix_world</code>.</strong> After a location edit, <code>matrix_world</code> is unchanged until <code>view_layer.update()</code> (same half of the orrery contract).</li><li><strong>Scale apply via data API.</strong> Non-uniform scale baked into verts; <code>obj.scale == (1,1,1)</code> exactly afterward.</li><li><strong>Origin at base center.</strong> Local bbox <code>min.z == 0</code>, XY centered; world AABB delta across the bake is <strong>0</strong> (gate <code>1e-5</code>).</li><li><strong>Bare-parent trap.</strong> Parenting the accessory without MPI jumps it (~0.43 m measured); setting <code>matrix_parent_inverse</code> restores world location (err ~3e-8).</li></ul>
-<p><strong>What each check catches on failure:</strong> skipping scale apply leaves non-identity scale; skipping origin bake leaves <code>min.z ≈ -0.756</code>; skipping MPI leaves the accessory teleported.</p>
-<p><strong>Version witness:</strong> byte-identical numbers on Blender 4.5.11 LTS and 5.1.2.</p>
-<p>The render is a dual panel: left <strong>TRAP</strong> (bare parent — flanged conduit teleports off a deep shadowed mount socket) vs right <strong>MPI KEEP</strong> (same metal fitting seated in the socket), with emissive origin markers at each pedestal&#x27;s base. The origin is inside the plinth, so the red X and green Y stubs are centred on it and run 1.7 m along the floor, exiting the plinth on both sides: where they cross, under the base, is the origin. The first cut drew 0.28 m stubs from the origin outward, all buried, and 0.11 m labels that vanished at card size; the labels are 0.21 m now. Accessory and pedestal stay in one material family so displacement — not color — carries the proof. Check closed forms are unchanged.</p>
+<ul><li><strong>Stale <code>matrix_world</code>.</strong> After a location edit, <code>matrix_world</code> is unchanged until <code>view_layer.update()</code> (same half of the orrery contract).</li><li><strong>Scale apply via data API.</strong> Non-uniform scale baked into verts; <code>obj.scale == (1,1,1)</code> exactly afterward.</li><li><strong>Origin at base center.</strong> Local bbox <code>min.z == 0</code>, XY centered; world AABB delta across the bake is <strong>0</strong> (gate <code>1e-5</code>).</li><li><strong>Bare-parent trap.</strong> Parenting the accessory without MPI jumps it (0.298 m measured); setting <code>matrix_parent_inverse</code> restores world location (err 0).</li></ul>
+<p><strong>What each check catches on failure:</strong> skipping scale apply leaves <code>(1.15, 0.92, 1.08)</code> (exit 5); skipping the origin bake leaves <code>min.z = -0.58</code> (exit 6); skipping MPI leaves the accessory 0.298 m off (exit 8).</p>
+<p><strong>Version witness:</strong> identical numbers on Blender 5.2.1 LTS, 5.1.2 and 4.5.11 LTS.</p>
+<p><strong>The asset.</strong> The pedestal is one mesh with five materials: a precast concrete footing, a galvanised base plate with anchor nuts, a green cabinet on a black kick skirt, a hipped lid, a door with hinges, a T-handle and a hazard plate, louvred side vents, a conduit boss on the +X face and a sleeve in the pad. It is authored the way an import often arrives: origin at the geometric centre and coordinates divided by a non-uniform object scale. The bake lands it on exactly the designed shape. The accessory is a flanged PVC conduit elbow with bolt heads, a strap clamp and a coupling that drops into the sleeve.</p>
+<p><strong>The render.</strong> Two baked pedestals stand on a sidewalk slab. On the left the elbow is parented with MPI and stays bolted to its boss, seated in the sleeve. On the right, bare <code>child.parent = parent</code> applies the pedestal&#x27;s transform a second time. The elbow is thrown 0.65 m, past the slab edge and into the air, and a glowing cyan outline (a Wireframe modifier on a copy) marks the seat it left. The slab raises both origins 0.20 m, so the doubled translation lifts the elbow instead of sliding it along the floor. A pivot ring on the floor is centred on each pedestal&#x27;s origin, with red notches on its X axis and green notches on Y. The origin is under the base, so the ring frames it. There are no text labels: the ghost and the stranded elbow carry the proof. The check&#x27;s closed forms are unchanged.</p>
 <h2>Run</h2>
 <pre><code>blender --background --python prop_origin_transform.py --
 blender --background --python prop_origin_transform.py -- --skip-mpi
@@ -293,7 +294,7 @@ <h2>Run</h2>
 blender --background --python prop_origin_transform.py -- --output origin.png --engine cycles</code></pre>
 <h2>Exit codes</h2>
 <p>Per-script sequential checks. <code>9</code> is a valid check code; there is no rule against it. <code>10</code> is the shared framing helper.</p>
-<div class="table-wrap"><table><thead><tr><th scope="col">Code</th><th scope="col">Meaning</th></tr></thead><tbody><tr><td>0</td><td>Success</td></tr><tr><td>1</td><td>Uncaught exception (FATAL wrapper)</td></tr><tr><td>2</td><td>argparse / usage</td></tr><tr><td>3</td><td>Stale <code>matrix_world</code> contract broken</td></tr><tr><td>4</td><td>World bbox moved across bake</td></tr><tr><td>5</td><td>Scale after bake is not (1,1,1)</td></tr><tr><td>6</td><td>Origin not at local base center</td></tr><tr><td>7</td><td>Bare parenting did not jump</td></tr><tr><td>8</td><td>MPI did not restore world location (<code>--skip-mpi</code> lands here)</td></tr><tr><td>9</td><td><code>--output</code> produced no file</td></tr><tr><td>10</td><td>Gallery framing violation</td></tr></tbody></table></div>
+<div class="table-wrap"><table><thead><tr><th scope="col">Code</th><th scope="col">Meaning</th></tr></thead><tbody><tr><td>0</td><td>Success</td></tr><tr><td>1</td><td>Uncaught exception (FATAL wrapper)</td></tr><tr><td>2</td><td>argparse / usage</td></tr><tr><td>3</td><td>Stale <code>matrix_world</code> contract broken</td></tr><tr><td>4</td><td>World bbox moved across bake</td></tr><tr><td>5</td><td>Scale after bake is not (1,1,1)</td></tr><tr><td>6</td><td>Origin not at local base center</td></tr><tr><td>7</td><td>Bare parenting did not jump</td></tr><tr><td>8</td><td>MPI did not restore world location (<code>--skip-mpi</code> lands here)</td></tr><tr><td>9</td><td><code>--output</code> produced no file</td></tr><tr><td>10</td><td>Gallery framing violation</td></tr><tr><td>11</td><td>Gallery asset-quality violation (render path only)</td></tr></tbody></table></div>
 <p>The <code>blender-smoke</code> workflow runs the check on Blender 5.2 LTS and 4.5 LTS (5.1 on the weekly cron, the <code>needs-5.1</code> PR label, or manual dispatch). Smoke does not pass <code>--output</code> or <code>--skip-mpi</code>.</p>
     </section>
     <section class="detail-section src">
@@ -309,7 +310,7 @@ <h2>Source</h2>
 to exactly (1,1,1), world bbox unchanged across the bake, and
 `matrix_parent_inverse` so a parented accessory does not teleport. Extends
 `parent-inverse-orrery` (MPI idiom + stale `matrix_world`) without retreading
-orbits — subject is a street utility pedestal with a bolted conduit accessory.
+orbits — subject is a street utility pedestal with a flanged conduit elbow.
 
 ``--skip-mpi`` parents the accessory without MPI and still asserts the restore.
 That is the falsifier (``--same-axis`` in export-preset-axis).
@@ -324,10 +325,11 @@ <h2>Source</h2>
 <span class="k">import</span> bpy, bmesh, sys, os, math, argparse
 <span class="k">from</span> mathutils <span class="k">import</span> Matrix, Vector
 
-<span class="c"># Shared Layer 1 framing measurement (render path only) — see gallery_framing.py</span>
+<span class="c"># Shared Layer 1 measurement (render path only) — see gallery_framing.py</span>
 sys.path.insert(<span class="n">0</span>, os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir))
 sys.dont_write_bytecode = <span class="k">True</span>  <span class="c"># keep examples/__pycache__ out of the repo tree</span>
 <span class="k">import</span> gallery_framing
+<span class="k">import</span> gallery_asset_quality
 
 BBOX_EPS = <span class="n">1e-6</span>
 WORLD_EPS = <span class="n">1e-5</span>
@@ -335,6 +337,25 @@ <h2>Source</h2>
 STALE_EPS = <span class="n">1e-9</span>
 JUMP_MIN = <span class="n">0.05</span>
 
+<span class="c"># The pedestal arrives the way an import often does: origin at the geometric</span>
+<span class="c"># centre and a non-uniform object scale compensating mesh data authored in</span>
+<span class="c"># the wrong units. The bake must land the mesh on exactly the designed shape.</span>
+PROP_SCALE = (<span class="n">1.15</span>, <span class="n">0.92</span>, <span class="n">1.08</span>)
+
+<span class="c"># Designed dimensions (metres, base-centre origin).</span>
+PAD = (<span class="n">1.04</span>, <span class="n">0.62</span>, <span class="n">0.10</span>)            <span class="c"># precast concrete footing</span>
+BODY_XY = (<span class="n">0.46</span>, <span class="n">0.36</span>)
+BODY_Z = (<span class="n">0.125</span>, <span class="n">1.05</span>)
+MOUNT_Z = <span class="n">0.45</span>                       <span class="c"># conduit boss on the +X side face</span>
+MOUNT = Vector((BODY_XY[<span class="n">0</span>] / <span class="n">2</span> + <span class="n">0.012</span>, <span class="n">0.0</span>, MOUNT_Z))   <span class="c"># flange seat face</span>
+SLEEVE = Vector((<span class="n">0.41</span>, <span class="n">0.0</span>, PAD[<span class="n">2</span>]))  <span class="c"># pad sleeve the conduit drops into</span>
+SLEEVE_H = <span class="n">0.05</span>
+SLAB_H = <span class="n">0.20</span>                       <span class="c"># render only: sidewalk slab under both copies</span>
+
+<span class="c"># Material slots</span>
+M_PAINT, M_GALV, M_CONCRETE, M_DARK, M_LABEL = range(<span class="n">5</span>)
+A_PVC, A_GALV = range(<span class="n">2</span>)
+
 
 <span class="k">def</span> eevee_engine_id():
     <span class="k">return</span> <span class="s">&quot;BLENDER_EEVEE&quot;</span> <span class="k">if</span> bpy.app.version &gt;= (<span class="n">5</span>, <span class="n">0</span>, <span class="n">0</span>) <span class="k">else</span> <span class="s">&quot;BLENDER_EEVEE_NEXT&quot;</span>
@@ -354,6 +375,260 @@ <h2>Source</h2>
     <span class="k">return</span> mat
 
 
+<span class="k">def</span> pedestal_materials(tag=<span class="s">&quot;&quot;</span>):
+    <span class="k">return</span> [
+        make_material(<span class="s">f&quot;</span><span class="s">PedestalPaint</span>{tag}<span class="s">&quot;</span>, (<span class="n">0.05</span>, <span class="n">0.36</span>, <span class="n">0.20</span>), rough=<span class="n">0.42</span>, metallic=<span class="n">0.15</span>),
+        make_material(<span class="s">f&quot;</span><span class="s">GalvSteel</span>{tag}<span class="s">&quot;</span>, (<span class="n">0.62</span>, <span class="n">0.64</span>, <span class="n">0.66</span>), rough=<span class="n">0.32</span>, metallic=<span class="n">0.85</span>),
+        make_material(<span class="s">f&quot;</span><span class="s">Concrete</span>{tag}<span class="s">&quot;</span>, (<span class="n">0.36</span>, <span class="n">0.35</span>, <span class="n">0.33</span>), rough=<span class="n">0.88</span>, metallic=<span class="n">0.0</span>),
+        make_material(<span class="s">f&quot;</span><span class="s">BlackRubber</span>{tag}<span class="s">&quot;</span>, (<span class="n">0.025</span>, <span class="n">0.026</span>, <span class="n">0.028</span>), rough=<span class="n">0.55</span>, metallic=<span class="n">0.0</span>),
+        make_material(<span class="s">f&quot;</span><span class="s">HazardLabel</span>{tag}<span class="s">&quot;</span>, (<span class="n">0.95</span>, <span class="n">0.66</span>, <span class="n">0.02</span>), rough=<span class="n">0.45</span>, metallic=<span class="n">0.0</span>),
+    ]
+
+
+<span class="k">def</span> conduit_materials(tag=<span class="s">&quot;&quot;</span>):
+    <span class="k">return</span> [
+        make_material(<span class="s">f&quot;</span><span class="s">ConduitPVC</span>{tag}<span class="s">&quot;</span>, (<span class="n">0.92</span>, <span class="n">0.30</span>, <span class="n">0.03</span>), rough=<span class="n">0.38</span>, metallic=<span class="n">0.0</span>),
+        make_material(<span class="s">f&quot;</span><span class="s">ConduitGalv</span>{tag}<span class="s">&quot;</span>, (<span class="n">0.62</span>, <span class="n">0.64</span>, <span class="n">0.66</span>), rough=<span class="n">0.32</span>, metallic=<span class="n">0.85</span>),
+    ]
+
+
+<span class="c"># ---------------------------------------------------------------------------</span>
+<span class="c"># Modelling. Every part is built in one bmesh; each helper tags the faces it</span>
+<span class="c"># creates with a material slot and a shading mode.</span>
+
+
+<span class="k">class</span> Part:
+    <span class="s">&quot;&quot;&quot;Context for one part: new verts/faces are the set difference.&quot;&quot;&quot;</span>
+
+    <span class="k">def</span> __init__(self, bm):
+        self.bm = bm
+        self.v0 = set(bm.verts)
+        self.f0 = set(bm.faces)
+
+    <span class="k">def</span> verts(self):
+        <span class="k">return</span> [v <span class="k">for</span> v <span class="k">in</span> self.bm.verts <span class="k">if</span> v <span class="k">not</span> <span class="k">in</span> self.v0]
+
+    <span class="k">def</span> finish(self, mat, smooth_axis=<span class="k">None</span>):
+        <span class="k">for</span> f <span class="k">in</span> self.bm.faces:
+            <span class="k">if</span> f <span class="k">in</span> self.f0:
+                <span class="k">continue</span>
+            f.material_index = mat
+            <span class="k">if</span> smooth_axis <span class="k">is</span> <span class="k">None</span>:
+                f.smooth = <span class="k">False</span>
+            <span class="k">else</span>:
+                f.normal_update()
+                f.smooth = abs(f.normal.dot(smooth_axis)) &lt; <span class="n">0.9</span>
+
+
+<span class="k">def</span> box(bm, center, size, mat, bevel=<span class="n">0.0</span>, rot=<span class="k">None</span>):
+    part = Part(bm)
+    geom = bmesh.ops.create_cube(bm, size=<span class="n">1.0</span>)
+    <span class="k">for</span> v <span class="k">in</span> geom[<span class="s">&quot;verts&quot;</span>]:
+        v.co = Vector((v.co.x * size[<span class="n">0</span>], v.co.y * size[<span class="n">1</span>], v.co.z * size[<span class="n">2</span>]))
+    <span class="k">if</span> bevel &gt; <span class="n">0.0</span>:
+        edges = list({e <span class="k">for</span> v <span class="k">in</span> geom[<span class="s">&quot;verts&quot;</span>] <span class="k">for</span> e <span class="k">in</span> v.link_edges})
+        bmesh.ops.bevel(
+            bm, geom=edges, offset=bevel, segments=<span class="n">2</span>, profile=<span class="n">0.5</span>, affect=<span class="s">&quot;EDGES&quot;</span>,
+            clamp_overlap=<span class="k">True</span>,
+        )
+    m = Matrix.Translation(Vector(center))
+    <span class="k">if</span> rot <span class="k">is</span> <span class="k">not</span> <span class="k">None</span>:
+        m = m @ rot
+    bmesh.ops.transform(bm, matrix=m, verts=part.verts())
+    part.finish(mat)
+
+
+<span class="k">def</span> _axis_matrix(axis):
+    <span class="s">&quot;&quot;&quot;Rotation taking +Z onto *axis* (a unit Vector).&quot;&quot;&quot;</span>
+    <span class="k">return</span> Vector((<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">1.0</span>)).rotation_difference(axis).to_matrix().to_4x4()
+
+
+<span class="k">def</span> cyl(bm, start, axis, length, r0, r1, mat, segs=<span class="n">24</span>, smooth=<span class="k">True</span>, bevel=<span class="n">0.0</span>):
+    <span class="s">&quot;&quot;&quot;Frustum from *start* along unit *axis*, radius r0 -&gt; r1.&quot;&quot;&quot;</span>
+    part = Part(bm)
+    axis = Vector(axis).normalized()
+    geom = bmesh.ops.create_cone(
+        bm, cap_ends=<span class="k">True</span>, cap_tris=<span class="k">False</span>, segments=segs,
+        radius1=r0, radius2=r1, depth=length,
+    )
+    <span class="k">if</span> bevel &gt; <span class="n">0.0</span>:
+        <span class="c"># Chamfer the two cap rims so machined parts catch a highlight.</span>
+        rims = [e <span class="k">for</span> e <span class="k">in</span> {e <span class="k">for</span> v <span class="k">in</span> geom[<span class="s">&quot;verts&quot;</span>] <span class="k">for</span> e <span class="k">in</span> v.link_edges}
+                <span class="k">if</span> abs(e.verts[<span class="n">0</span>].co.z - e.verts[<span class="n">1</span>].co.z) &lt; <span class="n">1e-9</span>]
+        bmesh.ops.bevel(
+            bm, geom=rims, offset=bevel, segments=<span class="n">2</span>, profile=<span class="n">0.5</span>, affect=<span class="s">&quot;EDGES&quot;</span>,
+            clamp_overlap=<span class="k">True</span>,
+        )
+    mat4 = Matrix.Translation(Vector(start) + axis * (length * <span class="n">0.5</span>)) @ _axis_matrix(axis)
+    bmesh.ops.transform(bm, matrix=mat4, verts=part.verts())
+    part.finish(mat, axis <span class="k">if</span> smooth <span class="k">else</span> <span class="k">None</span>)
+
+
+<span class="k">def</span> frustum_box(bm, z0, z1, lo, hi, mat):
+    <span class="s">&quot;&quot;&quot;Hip lid: rectangle *lo* (x,y) at z0 rising to rectangle *hi* at z1.&quot;&quot;&quot;</span>
+    part = Part(bm)
+    ring = []
+    <span class="k">for</span> (hx, hy), z <span class="k">in</span> ((lo, z0), (hi, z1)):
+        ring.append([bm.verts.new((sx * hx / <span class="n">2</span>, sy * hy / <span class="n">2</span>, z))
+                     <span class="k">for</span> sx, sy <span class="k">in</span> ((-<span class="n">1</span>, -<span class="n">1</span>), (<span class="n">1</span>, -<span class="n">1</span>), (<span class="n">1</span>, <span class="n">1</span>), (-<span class="n">1</span>, <span class="n">1</span>))])
+    a, b = ring
+    <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]))
+    bm.faces.new((a[<span class="n">0</span>], a[<span class="n">3</span>], a[<span class="n">2</span>], a[<span class="n">1</span>]))
+    bm.faces.new((b[<span class="n">0</span>], b[<span class="n">1</span>], b[<span class="n">2</span>], b[<span class="n">3</span>]))
+    part.finish(mat)
+
+
+<span class="k">def</span> elbow(bm, start, radius, bend_r, mat, segs=<span class="n">20</span>, steps=<span class="n">10</span>):
+    <span class="s">&quot;&quot;&quot;Quarter bend from *start* heading +X, turning down to -Z (XZ plane).&quot;&quot;&quot;</span>
+    part = Part(bm)
+    rings = []
+    <span class="k">for</span> i <span class="k">in</span> range(steps + <span class="n">1</span>):
+        a = (math.pi / <span class="n">2</span>) * i / steps
+        c = Vector(start) + Vector((bend_r * math.sin(a), <span class="n">0.0</span>, -bend_r + bend_r * math.cos(a)))
+        t = Vector((math.cos(a), <span class="n">0.0</span>, -math.sin(a)))
+        n = t.cross(Vector((<span class="n">0.0</span>, <span class="n">1.0</span>, <span class="n">0.0</span>))).normalized()  <span class="c"># in-plane normal</span>
+        b = Vector((<span class="n">0.0</span>, <span class="n">1.0</span>, <span class="n">0.0</span>))
+        rings.append([bm.verts.new(c + radius * (math.cos(<span class="n">2</span> * math.pi * k / segs) * n
+                                                 + math.sin(<span class="n">2</span> * math.pi * k / segs) * b))
+                      <span class="k">for</span> k <span class="k">in</span> range(segs)])
+    <span class="k">for</span> r0, r1 <span class="k">in</span> zip(rings, rings[<span class="n">1</span>:]):
+        <span class="k">for</span> k <span class="k">in</span> range(segs):
+            m = (k + <span class="n">1</span>) % segs
+            f = bm.faces.new((r0[k], r0[m], r1[m], r1[k]))
+    part.finish(mat)
+    <span class="k">for</span> f <span class="k">in</span> bm.faces:
+        <span class="k">if</span> f <span class="k">not</span> <span class="k">in</span> part.f0:
+            f.smooth = <span class="k">True</span>
+
+
+<span class="k">def</span> build_pedestal_design(bm):
+    <span class="s">&quot;&quot;&quot;Street utility pedestal, designed shape, origin at the base centre.&quot;&quot;&quot;</span>
+    up = (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">1.0</span>)
+    <span class="c"># Precast footing and the galvanised base plate with four anchor nuts.</span>
+    box(bm, (<span class="n">0</span>, <span class="n">0</span>, PAD[<span class="n">2</span>] / <span class="n">2</span>), PAD, M_CONCRETE, bevel=<span class="n">0.025</span>)
+    box(bm, (<span class="n">0</span>, <span class="n">0</span>, PAD[<span class="n">2</span>] + <span class="n">0.0125</span>), (<span class="n">0.58</span>, <span class="n">0.46</span>, <span class="n">0.025</span>), M_GALV, bevel=<span class="n">0.006</span>)
+    <span class="k">for</span> sx <span class="k">in</span> (-<span class="n">1</span>, <span class="n">1</span>):
+        <span class="k">for</span> sy <span class="k">in</span> (-<span class="n">1</span>, <span class="n">1</span>):
+            c = Vector((sx * <span class="n">0.25</span>, sy * <span class="n">0.19</span>, PAD[<span class="n">2</span>] + <span class="n">0.025</span>))
+            cyl(bm, c, up, <span class="n">0.006</span>, <span class="n">0.026</span>, <span class="n">0.026</span>, M_GALV, segs=<span class="n">16</span>)
+            cyl(bm, c + Vector((<span class="n">0</span>, <span class="n">0</span>, <span class="n">0.006</span>)), up, <span class="n">0.02</span>, <span class="n">0.019</span>, <span class="n">0.019</span>, M_DARK,
+                segs=<span class="n">6</span>, smooth=<span class="k">False</span>)
+            cyl(bm, c + Vector((<span class="n">0</span>, <span class="n">0</span>, <span class="n">0.026</span>)), up, <span class="n">0.012</span>, <span class="n">0.008</span>, <span class="n">0.006</span>, M_GALV, segs=<span class="n">10</span>)
+    <span class="c"># Cabinet body over a black kick skirt.</span>
+    zc = <span class="n">0.5</span> * (BODY_Z[<span class="n">0</span>] + BODY_Z[<span class="n">1</span>])
+    box(bm, (<span class="n">0</span>, <span class="n">0</span>, zc), (BODY_XY[<span class="n">0</span>], BODY_XY[<span class="n">1</span>], BODY_Z[<span class="n">1</span>] - BODY_Z[<span class="n">0</span>]), M_PAINT,
+        bevel=<span class="n">0.022</span>)
+    box(bm, (<span class="n">0</span>, <span class="n">0</span>, BODY_Z[<span class="n">0</span>] + <span class="n">0.045</span>), (BODY_XY[<span class="n">0</span>] + <span class="n">0.02</span>, BODY_XY[<span class="n">1</span>] + <span class="n">0.02</span>, <span class="n">0.09</span>),
+        M_DARK, bevel=<span class="n">0.01</span>)
+    <span class="c"># Overhanging lid with a hipped cap.</span>
+    box(bm, (<span class="n">0</span>, <span class="n">0</span>, BODY_Z[<span class="n">1</span>] + <span class="n">0.02</span>), (<span class="n">0.52</span>, <span class="n">0.42</span>, <span class="n">0.04</span>), M_PAINT, bevel=<span class="n">0.012</span>)
+    frustum_box(bm, BODY_Z[<span class="n">1</span>] + <span class="n">0.04</span>, BODY_Z[<span class="n">1</span>] + <span class="n">0.11</span>, (<span class="n">0.50</span>, <span class="n">0.40</span>), (<span class="n">0.30</span>, <span class="n">0.20</span>),
+                M_PAINT)
+    <span class="c"># Front access door: dark shadow gap, raised panel, hinges, T-handle lock.</span>
+    fy = -BODY_XY[<span class="n">1</span>] / <span class="n">2</span>
+    box(bm, (<span class="n">0</span>, fy - <span class="n">0.002</span>, <span class="n">0.60</span>), (<span class="n">0.37</span>, <span class="n">0.006</span>, <span class="n">0.70</span>), M_DARK, bevel=<span class="n">0.002</span>)
+    box(bm, (<span class="n">0</span>, fy - <span class="n">0.009</span>, <span class="n">0.60</span>), (<span class="n">0.35</span>, <span class="n">0.012</span>, <span class="n">0.68</span>), M_PAINT, bevel=<span class="n">0.005</span>)
+    <span class="k">for</span> z <span class="k">in</span> (<span class="n">0.36</span>, <span class="n">0.84</span>):
+        cyl(bm, (-<span class="n">0.182</span>, fy - <span class="n">0.012</span>, z - <span class="n">0.04</span>), up, <span class="n">0.08</span>, <span class="n">0.009</span>, <span class="n">0.009</span>, M_GALV, segs=<span class="n">12</span>)
+    cyl(bm, (<span class="n">0.12</span>, fy - <span class="n">0.015</span>, <span class="n">0.62</span>), (<span class="n">0</span>, -<span class="n">1</span>, <span class="n">0</span>), <span class="n">0.014</span>, <span class="n">0.022</span>, <span class="n">0.022</span>, M_GALV, segs=<span class="n">20</span>,
+        bevel=<span class="n">0.003</span>)
+    box(bm, (<span class="n">0.12</span>, fy - <span class="n">0.034</span>, <span class="n">0.62</span>), (<span class="n">0.018</span>, <span class="n">0.012</span>, <span class="n">0.10</span>), M_GALV, bevel=<span class="n">0.004</span>)
+    <span class="c"># Hazard plate high on the door: black border, yellow face, black mark.</span>
+    box(bm, (<span class="n">0</span>, fy - <span class="n">0.016</span>, <span class="n">0.87</span>), (<span class="n">0.17</span>, <span class="n">0.003</span>, <span class="n">0.11</span>), M_DARK, bevel=<span class="n">0.001</span>)
+    box(bm, (<span class="n">0</span>, fy - <span class="n">0.018</span>, <span class="n">0.87</span>), (<span class="n">0.155</span>, <span class="n">0.003</span>, <span class="n">0.095</span>), M_LABEL, bevel=<span class="n">0.001</span>)
+    cyl(bm, (<span class="n">0</span>, fy - <span class="n">0.0195</span>, <span class="n">0.862</span>), (<span class="n">0</span>, -<span class="n">1</span>, <span class="n">0</span>), <span class="n">0.002</span>, <span class="n">0.034</span>, <span class="n">0.034</span>, M_DARK, segs=<span class="n">3</span>,
+        smooth=<span class="k">False</span>)
+    <span class="c"># Louvred vents high on both sides.</span>
+    <span class="k">for</span> sx <span class="k">in</span> (-<span class="n">1</span>, <span class="n">1</span>):
+        x = sx * BODY_XY[<span class="n">0</span>] / <span class="n">2</span>
+        box(bm, (x + sx * <span class="n">0.002</span>, <span class="n">0</span>, <span class="n">0.87</span>), (<span class="n">0.006</span>, <span class="n">0.24</span>, <span class="n">0.17</span>), M_DARK, bevel=<span class="n">0.001</span>)
+        <span class="k">for</span> i <span class="k">in</span> range(<span class="n">5</span>):
+            box(bm, (x + sx * <span class="n">0.012</span>, <span class="n">0</span>, <span class="n">0.805</span> + i * <span class="n">0.032</span>), (<span class="n">0.022</span>, <span class="n">0.23</span>, <span class="n">0.012</span>), M_PAINT,
+                bevel=<span class="n">0.003</span>, rot=Matrix.Rotation(sx * math.radians(-<span class="n">35</span>), <span class="n">4</span>, <span class="s">&quot;Y&quot;</span>))
+    <span class="c"># Conduit boss on the +X face (the accessory&#x27;s seat) and the pad sleeve.</span>
+    cyl(bm, (BODY_XY[<span class="n">0</span>] / <span class="n">2</span>, <span class="n">0</span>, MOUNT_Z), (<span class="n">1</span>, <span class="n">0</span>, <span class="n">0</span>), MOUNT.x - BODY_XY[<span class="n">0</span>] / <span class="n">2</span>, <span class="n">0.108</span>,
+        <span class="n">0.108</span>, M_GALV, segs=<span class="n">32</span>, bevel=<span class="n">0.003</span>)
+    cyl(bm, SLEEVE, up, SLEEVE_H, <span class="n">0.076</span>, <span class="n">0.076</span>, M_GALV, segs=<span class="n">28</span>, bevel=<span class="n">0.004</span>)
+    cyl(bm, SLEEVE + Vector((<span class="n">0</span>, <span class="n">0</span>, SLEEVE_H)), up, <span class="n">0.002</span>, <span class="n">0.06</span>, <span class="n">0.06</span>, M_DARK, segs=<span class="n">28</span>)
+
+
+<span class="k">def</span> build_pedestal_mesh(name=<span class="s">&quot;StreetPedestal&quot;</span>):
+    <span class="s">&quot;&quot;&quot;Pedestal mesh in its as-imported state (see PROP_SCALE).&quot;&quot;&quot;</span>
+    me = bpy.data.meshes.new(name)
+    bm = bmesh.new()
+    <span class="k">try</span>:
+        build_pedestal_design(bm)
+        <span class="c"># Origin at the geometric centre, coordinates divided by the object</span>
+        <span class="c"># scale the import will carry.</span>
+        xs = [v.co.x <span class="k">for</span> v <span class="k">in</span> bm.verts]
+        ys = [v.co.y <span class="k">for</span> v <span class="k">in</span> bm.verts]
+        zs = [v.co.z <span class="k">for</span> v <span class="k">in</span> bm.verts]
+        c = Vector((<span class="n">0.5</span> * (min(xs) + max(xs)), <span class="n">0.5</span> * (min(ys) + max(ys)),
+                    <span class="n">0.5</span> * (min(zs) + max(zs))))
+        <span class="k">for</span> v <span class="k">in</span> bm.verts:
+            p = v.co - c
+            v.co = Vector((p.x / PROP_SCALE[<span class="n">0</span>], p.y / PROP_SCALE[<span class="n">1</span>], p.z / PROP_SCALE[<span class="n">2</span>]))
+        bm.normal_update()
+        bm.to_mesh(me)
+    <span class="k">finally</span>:
+        bm.free()
+    <span class="k">for</span> m <span class="k">in</span> pedestal_materials():
+        me.materials.append(m)
+    <span class="k">return</span> me
+
+
+<span class="k">def</span> build_conduit_design(bm):
+    <span class="s">&quot;&quot;&quot;Flanged conduit elbow. Origin at the flange&#x27;s mounting face, +X out of
+    the pedestal, the drop leg ending in a coupling that seats in the sleeve.&quot;&quot;&quot;</span>
+    xa = Vector((<span class="n">1</span>, <span class="n">0</span>, <span class="n">0</span>))
+    down = Vector((<span class="n">0</span>, <span class="n">0</span>, -<span class="n">1</span>))
+    r = <span class="n">0.05</span>                         <span class="c"># conduit outside radius</span>
+    bend_r = <span class="n">0.10</span>
+    leg_x = SLEEVE.x - MOUNT.x
+    x_bend = leg_x - bend_r
+    z_seat = SLEEVE.z + SLEEVE_H - MOUNT.z
+    <span class="c"># Flange with four bolt heads.</span>
+    cyl(bm, (<span class="n">0</span>, <span class="n">0</span>, <span class="n">0</span>), xa, <span class="n">0.02</span>, <span class="n">0.095</span>, <span class="n">0.095</span>, A_GALV, segs=<span class="n">32</span>, bevel=<span class="n">0.004</span>)
+    <span class="k">for</span> k <span class="k">in</span> range(<span class="n">4</span>):
+        a = math.radians(<span class="n">45</span> + <span class="n">90</span> * k)
+        cyl(bm, (<span class="n">0.02</span>, <span class="n">0.068</span> * math.cos(a), <span class="n">0.068</span> * math.sin(a)), xa, <span class="n">0.012</span>, <span class="n">0.014</span>,
+            <span class="n">0.014</span>, A_GALV, segs=<span class="n">6</span>, smooth=<span class="k">False</span>)
+    <span class="c"># Hub, horizontal run, bend, drop leg.</span>
+    cyl(bm, (<span class="n">0.02</span>, <span class="n">0</span>, <span class="n">0</span>), xa, <span class="n">0.03</span>, r + <span class="n">0.012</span>, r + <span class="n">0.012</span>, A_PVC, segs=<span class="n">28</span>, bevel=<span class="n">0.004</span>)
+    cyl(bm, (<span class="n">0.05</span>, <span class="n">0</span>, <span class="n">0</span>), xa, x_bend - <span class="n">0.05</span>, r, r, A_PVC, segs=<span class="n">28</span>)
+    elbow(bm, (x_bend, <span class="n">0</span>, <span class="n">0</span>), r, bend_r, A_PVC, segs=<span class="n">28</span>)
+    leg_top = Vector((leg_x, <span class="n">0</span>, -bend_r))
+    leg_len = (-bend_r) - (z_seat + <span class="n">0.05</span>)
+    cyl(bm, leg_top, down, leg_len, r, r, A_PVC, segs=<span class="n">28</span>)
+    <span class="c"># Strap clamp mid-leg and the coupling that sits on the sleeve.</span>
+    cyl(bm, leg_top + down * (leg_len * <span class="n">0.45</span>), down, <span class="n">0.022</span>, r + <span class="n">0.008</span>, r + <span class="n">0.008</span>, A_GALV,
+        segs=<span class="n">28</span>, bevel=<span class="n">0.003</span>)
+    box(bm, leg_top + down * (leg_len * <span class="n">0.45</span> + <span class="n">0.011</span>) + Vector((<span class="n">0</span>, r + <span class="n">0.014</span>, <span class="n">0</span>)),
+        (<span class="n">0.022</span>, <span class="n">0.024</span>, <span class="n">0.022</span>), A_GALV, bevel=<span class="n">0.004</span>)
+    cyl(bm, Vector((leg_x, <span class="n">0</span>, z_seat + <span class="n">0.05</span>)), down, <span class="n">0.05</span>, r + <span class="n">0.012</span>, r + <span class="n">0.012</span>, A_GALV,
+        segs=<span class="n">28</span>, bevel=<span class="n">0.004</span>)
+
+
+<span class="k">def</span> build_accessory_mesh(name=<span class="s">&quot;ConduitElbow&quot;</span>):
+    me = bpy.data.meshes.new(name)
+    bm = bmesh.new()
+    <span class="k">try</span>:
+        build_conduit_design(bm)
+        bm.normal_update()
+        bm.to_mesh(me)
+    <span class="k">finally</span>:
+        bm.free()
+    <span class="k">for</span> m <span class="k">in</span> conduit_materials():
+        me.materials.append(m)
+    <span class="k">return</span> me
+
+
+<span class="c"># ---------------------------------------------------------------------------</span>
+<span class="c"># Contract</span>
+
+
 <span class="k">def</span> local_bbox(me):
     xs = [v.co.x <span class="k">for</span> v <span class="k">in</span> me.vertices]
     ys = [v.co.y <span class="k">for</span> v <span class="k">in</span> me.vertices]
@@ -386,112 +661,6 @@ <h2>Source</h2>
     )
 
 
-<span class="k">def</span> build_pedestal_mesh():
-    <span class="s">&quot;&quot;&quot;Stepped street pedestal mesh in local space (origin roughly at center).&quot;&quot;&quot;</span>
-    rings = [
-        (<span class="n">0.55</span>, <span class="n">0.45</span>, -<span class="n">0.70</span>),
-        (<span class="n">0.55</span>, <span class="n">0.45</span>, -<span class="n">0.52</span>),
-        (<span class="n">0.42</span>, <span class="n">0.34</span>, -<span class="n">0.52</span>),
-        (<span class="n">0.42</span>, <span class="n">0.34</span>, <span class="n">0.55</span>),
-        (<span class="n">0.48</span>, <span class="n">0.38</span>, <span class="n">0.55</span>),
-        (<span class="n">0.48</span>, <span class="n">0.38</span>, <span class="n">0.70</span>),
-    ]
-    me = bpy.data.meshes.new(<span class="s">&quot;Pedestal&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> 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, top = ring_verts[<span class="n">0</span>], ring_verts[-<span class="n">1</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>]))
-        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>]))
-        bmesh.ops.recalc_face_normals(bm, faces=bm.faces)
-        bm.to_mesh(me)
-    <span class="k">finally</span>:
-        bm.free()
-    <span class="k">return</span> me
-
-
-<span class="k">def</span> build_accessory_mesh():
-    <span class="s">&quot;&quot;&quot;Flanged conduit stub — short pipe + mounting flange + bolt heads.&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); origin at flange face</span>
-        barrel = 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.08</span>, depth=<span class="n">0.48</span>,
-        )
-        bmesh.ops.rotate(
-            bm, verts=barrel[<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.24</span>, <span class="n">0.0</span>), verts=barrel[<span class="s">&quot;verts&quot;</span>])
-        <span class="c"># Thick mounting flange at the prop-facing (+Y local before rotate → y≈0)</span>
-        flange = bmesh.ops.create_cone(
-            bm, cap_ends=<span class="k">True</span>, segments=<span class="n">20</span>, radius1=<span class="n">0.20</span>, radius2=<span class="n">0.20</span>, depth=<span class="n">0.06</span>,
-        )
-        bmesh.ops.rotate(
-            bm, verts=flange[<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.03</span>, <span class="n">0.0</span>), verts=flange[<span class="s">&quot;verts&quot;</span>])
-        <span class="c"># Four bolt heads on the flange face (camera-visible when seated)</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.14</span> * math.cos(rad), <span class="n">0.14</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.032</span>, radius2=<span class="n">0.032</span>, depth=<span class="n">0.04</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.07</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;Deep mount well — shadowed interior reads as the vacated seat.&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 collar (matches flange OD)</span>
-        bmesh.ops.create_cone(
-            bm, cap_ends=<span class="k">True</span>, segments=<span class="n">24</span>, radius1=<span class="n">0.24</span>, radius2=<span class="n">0.24</span>, depth=<span class="n">0.07</span>,
-        )
-        <span class="c"># Deep dark well — into the prop after rotate</span>
-        well = bmesh.ops.create_cone(
-            bm, cap_ends=<span class="k">True</span>, segments=<span class="n">20</span>, radius1=<span class="n">0.13</span>, radius2=<span class="n">0.11</span>, depth=<span class="n">0.18</span>,
-        )
-        bmesh.ops.translate(bm, vec=(<span class="n">0.0</span>, <span class="n">0.0</span>, -<span class="n">0.06</span>), verts=well[<span class="s">&quot;verts&quot;</span>])
-        <span class="c"># Backstop disk (shadowed pocket floor)</span>
-        floor = bmesh.ops.create_cone(
-            bm, cap_ends=<span class="k">True</span>, segments=<span class="n">16</span>, radius1=<span class="n">0.10</span>, radius2=<span class="n">0.10</span>, depth=<span class="n">0.025</span>,
-        )
-        bmesh.ops.translate(bm, vec=(<span class="n">0.0</span>, <span class="n">0.0</span>, -<span class="n">0.16</span>), verts=floor[<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()
-    <span class="k">return</span> me
-
-
 <span class="k">def</span> apply_scale_data_api(obj):
     <span class="s">&quot;&quot;&quot;Bake non-uniform scale into mesh verts; leave obj.scale == (1,1,1).&quot;&quot;&quot;</span>
     sx, sy, sz = obj.scale
@@ -528,22 +697,13 @@ <h2>Source</h2>
     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;Body&quot;</span>, (<span class="n">0.20</span>, <span class="n">0.38</span>, <span class="n">0.34</span>), rough=<span class="n">0.42</span>, metallic=<span class="n">0.55</span>)
-    acc_m = make_material(<span class="s">&quot;Conduit&quot;</span>, (<span class="n">0.45</span>, <span class="n">0.42</span>, <span class="n">0.28</span>), rough=<span class="n">0.4</span>, metallic=<span class="n">0.7</span>)
-
-    me = build_pedestal_mesh()
-    me.materials.append(body_m)
-    <span class="k">for</span> p <span class="k">in</span> me.polygons:
-        p.use_smooth = <span class="k">False</span>
-    prop = bpy.data.objects.new(<span class="s">&quot;StreetPedestal&quot;</span>, me)
+    prop = bpy.data.objects.new(<span class="s">&quot;StreetPedestal&quot;</span>, build_pedestal_mesh())
     <span class="c"># Intentionally wrong for ingest: non-uniform scale, origin at geometry center</span>
-    prop.scale = (<span class="n">1.15</span>, <span class="n">0.92</span>, <span class="n">1.08</span>)
+    prop.scale = PROP_SCALE
     prop.location = (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>)
     sc.collection.objects.link(prop)
 
-    ame = build_accessory_mesh()
-    ame.materials.append(acc_m)
-    acc = bpy.data.objects.new(<span class="s">&quot;Accessory&quot;</span>, ame)
+    acc = bpy.data.objects.new(<span class="s">&quot;ConduitElbow&quot;</span>, build_accessory_mesh())
     <span class="c"># World pose before parenting — bolted to the front face mid-height</span>
     acc.location = (<span class="n">0.0</span>, -<span class="n">0.55</span>, <span class="n">0.15</span>)
     acc.rotation_euler = (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>)
@@ -669,68 +829,61 @@ <h2>Source</h2>
     <span class="k">return</span> <span class="n">0</span>
 
 
-<span class="k">def</span> origin_marker(sc, loc):
-    <span class="s">&quot;&quot;&quot;Emissive triad at the object origin — scene evidence, not a light.
+<span class="c"># ---------------------------------------------------------------------------</span>
+<span class="c"># Render</span>
 
-    The origin sits at the base centre, inside the plinth, so a bead alone is
-    buried. The X and Y stubs are centred on it and run long enough to exit
-    the plinth on both sides along the floor: where they cross, under the
-    pedestal, is the origin.
-    &quot;&quot;&quot;</span>
-    mat = make_material(
-        <span class="s">&quot;OriginMark&quot;</span>, (<span class="n">1.0</span>, <span class="n">0.55</span>, <span class="n">0.1</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.6</span>, <span class="n">0.1</span>), estr=<span class="n">2.2</span>,
-    )
-    me = bpy.data.meshes.new(<span class="s">&quot;OriginBead&quot;</span>)
+
+<span class="k">def</span> ghost_of(sc, src, name, mat):
+    <span class="s">&quot;&quot;&quot;Glowing wire outline of *src* at its current world pose: where the
+    accessory belongs. A Wireframe modifier on a copy, every slot the ghost
+    material.&quot;&quot;&quot;</span>
+    me = src.data.copy()
+    me.name = name
+    <span class="k">for</span> i <span class="k">in</span> range(len(me.materials)):
+        me.materials[i] = mat
+    ob = bpy.data.objects.new(name, me)
+    ob.matrix_world = src.matrix_world.copy()
+    sc.collection.objects.link(ob)
+    wf = ob.modifiers.new(<span class="s">&quot;Outline&quot;</span>, <span class="s">&quot;WIREFRAME&quot;</span>)
+    wf.thickness = <span class="n">0.005</span>
+    wf.use_replace = <span class="k">True</span>
+    wf.use_even_offset = <span class="k">True</span>
+    <span class="k">return</span> ob
+
+
+<span class="k">def</span> pivot_marker(sc, name, origin, rot_z, mats, reach):
+    <span class="s">&quot;&quot;&quot;Floor pivot target centred on the object origin: a thin ring around
+    the footing with crosshair notches on the object&#x27;s X and Y axes. The
+    origin itself is under the base, so the marker frames it.&quot;&quot;&quot;</span>
+    me = bpy.data.meshes.new(name)
     bm = bmesh.new()
     <span class="k">try</span>:
-        bmesh.ops.create_uvsphere(bm, u_segments=<span class="n">10</span>, v_segments=<span class="n">8</span>, radius=<span class="n">0.09</span>)
+        up = Vector((<span class="n">0</span>, <span class="n">0</span>, <span class="n">1</span>))
+        part = Part(bm)
+        bmesh.ops.create_circle(bm, cap_ends=<span class="k">False</span>, segments=<span class="n">96</span>, radius=reach)
+        ring_edges = [e <span class="k">for</span> e <span class="k">in</span> bm.edges]
+        ext = bmesh.ops.extrude_edge_only(bm, edges=ring_edges)
+        nv = [g <span class="k">for</span> g <span class="k">in</span> ext[<span class="s">&quot;geom&quot;</span>] <span class="k">if</span> isinstance(g, bmesh.types.BMVert)]
+        bmesh.ops.scale(bm, vec=(<span class="n">1</span> + <span class="n">0.018</span> / reach, <span class="n">1</span> + <span class="n">0.018</span> / reach, <span class="n">1</span>), verts=nv)
+        bmesh.ops.translate(bm, vec=(<span class="n">0</span>, <span class="n">0</span>, <span class="n">0.003</span>), verts=part.verts())
+        part.finish(<span class="n">2</span>)
+        <span class="c"># Crosshair notches on the object&#x27;s own X (red) and Y (green) axes:</span>
+        <span class="c"># the lines they sight along cross at the origin, under the base.</span>
+        <span class="k">for</span> k <span class="k">in</span> range(<span class="n">4</span>):
+            a = k * math.pi / <span class="n">2</span>
+            d = Vector((math.cos(a), math.sin(a), <span class="n">0.0</span>))
+            mid = d * (reach - <span class="n">0.05</span>) + up * <span class="n">0.006</span>
+            box(bm, mid, (<span class="n">0.17</span>, <span class="n">0.028</span>, <span class="n">0.008</span>), k % <span class="n">2</span>,
+                bevel=<span class="n">0.003</span>, rot=Matrix.Rotation(a, <span class="n">4</span>, <span class="s">&quot;Z&quot;</span>))
         bm.to_mesh(me)
     <span class="k">finally</span>:
         bm.free()
-    me.materials.append(mat)
-    ob = bpy.data.objects.new(<span class="s">&quot;OriginBead&quot;</span>, me)
-    ob.location = loc
-    sc.collection.objects.link(ob)
-    <span class="c"># Axis stubs</span>
-    <span class="k">for</span> axis, rgb, rot, depth <span class="k">in</span> (
-        (<span class="s">&quot;X&quot;</span>, (<span class="n">1.0</span>, <span class="n">0.2</span>, <span class="n">0.15</span>), (<span class="n">0</span>, math.radians(<span class="n">90</span>), <span class="n">0</span>), <span class="n">1.7</span>),
-        (<span class="s">&quot;Y&quot;</span>, (<span class="n">0.2</span>, <span class="n">1.0</span>, <span class="n">0.25</span>), (math.radians(-<span class="n">90</span>), <span class="n">0</span>, <span class="n">0</span>), <span class="n">1.7</span>),
-        (<span class="s">&quot;Z&quot;</span>, (<span class="n">0.25</span>, <span class="n">0.45</span>, <span class="n">1.0</span>), (<span class="n">0</span>, <span class="n">0</span>, <span class="n">0</span>), <span class="n">0.56</span>),
-    ):
-        ame = bpy.data.meshes.new(<span class="s">f&quot;</span><span class="s">Axis</span>{axis}<span class="s">&quot;</span>)
-        abm = bmesh.new()
-        <span class="k">try</span>:
-            bmesh.ops.create_cone(
-                abm, cap_ends=<span class="k">True</span>, segments=<span class="n">8</span>, radius1=<span class="n">0.022</span>, radius2=<span class="n">0.022</span>, depth=depth,
-            )
-            <span class="k">if</span> axis == <span class="s">&quot;Z&quot;</span>:
-                bmesh.ops.translate(abm, vec=(<span class="n">0</span>, <span class="n">0</span>, depth / <span class="n">2.0</span>), verts=abm.verts)
-            abm.to_mesh(ame)
-        <span class="k">finally</span>:
-            abm.free()
-        am = make_material(
-            <span class="s">f&quot;</span><span class="s">Axis</span>{axis}<span class="s">&quot;</span>, rgb, rough=<span class="n">0.4</span>, metallic=<span class="n">0.0</span>, emit=rgb, estr=<span class="n">1.5</span>,
-        )
-        ame.materials.append(am)
-        aob = bpy.data.objects.new(<span class="s">f&quot;</span><span class="s">Axis</span>{axis}<span class="s">&quot;</span>, ame)
-        <span class="c"># X and Y are centred on the origin, lifted one radius onto the floor</span>
-        aob.location = loc + Vector((<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.022</span> <span class="k">if</span> axis != <span class="s">&quot;Z&quot;</span> <span class="k">else</span> <span class="n">0.0</span>))
-        aob.rotation_euler = rot
-        sc.collection.objects.link(aob)
-
-
-<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 = size
-    cu.align_x = <span class="s">&quot;CENTER&quot;</span>
-    cu.extrude = <span class="n">0.006</span>
-    ob = bpy.data.objects.new(text, cu)
-    ob.location = loc
+    <span class="k">for</span> m <span class="k">in</span> mats:
+        me.materials.append(m)
+    ob = bpy.data.objects.new(name, me)
+    ob.location = origin
+    ob.rotation_euler.z = rot_z
     sc.collection.objects.link(ob)
-    mat = make_material(<span class="s">&quot;Label&quot;</span>, (<span class="n">0.92</span>, <span class="n">0.92</span>, <span class="n">0.94</span>), rough=<span class="n">0.6</span>, metallic=<span class="n">0.0</span>)
-    ob.data.materials.append(mat)
     <span class="k">return</span> ob
 
 
@@ -747,7 +900,7 @@ <h2>Source</h2>
     floor = bpy.data.objects.new(<span class="s">&quot;Floor&quot;</span>, floor_me)
     sc.collection.objects.link(floor)
     wall = bpy.data.objects.new(<span class="s">&quot;Wall&quot;</span>, floor_me.copy())
-    wall.location = (<span class="n">0.0</span>, <span class="n">9.0</span>, <span class="n">0.0</span>)
+    wall.location = (<span class="n">0.0</span>, <span class="n">7.0</span>, <span class="n">0.0</span>)
     wall.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(wall)
 
@@ -758,129 +911,118 @@ <h2>Source</h2>
     )
     sc.world = world
 
-    <span class="k">def</span> light(name, loc, energy, size, col, rot):
+    <span class="k">def</span> light(name, loc, energy, size, col, target):
         ld = bpy.data.lights.new(name, <span class="s">&quot;AREA&quot;</span>)
         ld.energy = energy
         ld.size = size
         ld.color = col
         ob = bpy.data.objects.new(name, ld)
         ob.location = loc
-        ob.rotation_euler = tuple(math.radians(a) <span class="k">for</span> a <span class="k">in</span> rot)
+        ob.rotation_euler = (Vector(target) - Vector(loc)).to_track_quat(<span class="s">&quot;-Z&quot;</span>, <span class="s">&quot;Y&quot;</span>).to_euler()
         sc.collection.objects.link(ob)
 
-    light(<span class="s">&quot;Key&quot;</span>, (-<span class="n">3.5</span>, -<span class="n">4.5</span>, <span class="n">5.5</span>), <span class="n">480.0</span>, <span class="n">4.5</span>, (<span class="n">1.0</span>, <span class="n">0.96</span>, <span class="n">0.9</span>), (<span class="n">48</span>, <span class="n">0</span>, -<span class="n">35</span>))
-    light(<span class="s">&quot;Fill&quot;</span>, (<span class="n">5.0</span>, -<span class="n">3.5</span>, <span class="n">2.5</span>), <span class="n">120.0</span>, <span class="n">9.0</span>, (<span class="n">0.75</span>, <span class="n">0.85</span>, <span class="n">1.0</span>), (<span class="n">65</span>, <span class="n">0</span>, <span class="n">50</span>))
-    light(<span class="s">&quot;Rim&quot;</span>, (<span class="n">1.5</span>, <span class="n">4.5</span>, <span class="n">3.5</span>), <span class="n">280.0</span>, <span class="n">3.0</span>, (<span class="n">0.6</span>, <span class="n">0.78</span>, <span class="n">1.0</span>), (-<span class="n">55</span>, <span class="n">0</span>, <span class="n">170</span>))
-    light(<span class="s">&quot;Wedge&quot;</span>, (<span class="n">2.5</span>, <span class="n">5.5</span>, <span class="n">4.0</span>), <span class="n">400.0</span>, <span class="n">6.0</span>, (<span class="n">1.0</span>, <span class="n">0.72</span>, <span class="n">0.42</span>), (-<span class="n">68</span>, <span class="n">0</span>, <span class="n">190</span>))
+    light(<span class="s">&quot;Key&quot;</span>, (-<span class="n">3.0</span>, -<span class="n">4.0</span>, <span class="n">5.0</span>), <span class="n">340.0</span>, <span class="n">3.0</span>, (<span class="n">1.0</span>, <span class="n">0.86</span>, <span class="n">0.68</span>), (<span class="n">0.2</span>, <span class="n">0</span>, <span class="n">0.6</span>))
+    light(<span class="s">&quot;Fill&quot;</span>, (<span class="n">4.5</span>, -<span class="n">4.0</span>, <span class="n">2.2</span>), <span class="n">45.0</span>, <span class="n">8.0</span>, (<span class="n">0.75</span>, <span class="n">0.85</span>, <span class="n">1.0</span>), (<span class="n">0.2</span>, <span class="n">0</span>, <span class="n">0.6</span>))
+    light(<span class="s">&quot;Rim&quot;</span>, (<span class="n">1.0</span>, <span class="n">3.0</span>, <span class="n">4.2</span>), <span class="n">150.0</span>, <span class="n">2.5</span>, (<span class="n">0.6</span>, <span class="n">0.78</span>, <span class="n">1.0</span>), (<span class="n">0.2</span>, <span class="n">0</span>, <span class="n">1.0</span>))
+    light(<span class="s">&quot;Wedge&quot;</span>, (<span class="n">2.0</span>, <span class="n">4.0</span>, <span class="n">3.5</span>), <span class="n">380.0</span>, <span class="n">6.0</span>, (<span class="n">1.0</span>, <span class="n">0.68</span>, <span class="n">0.36</span>), (<span class="n">0.5</span>, <span class="n">7.0</span>, <span class="n">0.7</span>))
     <span class="k">return</span> floor, wall
 
 
 <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="s">&quot;&quot;&quot;Two baked pedestals. Left: the conduit parented with MPI stays seated.
+    Right: bare `child.parent = parent` double-applies the parent transform
+    and the elbow is left hanging off its mount, a glowing outline marking
+    the seat it left.&quot;&quot;&quot;</span>
     bpy.ops.wm.read_factory_settings(use_empty=<span class="k">True</span>)
     sc = bpy.context.scene
 
-    <span class="c"># Teal pedestal — accessory shares metal fitting in the same family (no</span>
-    <span class="c"># primary-color emission blobs). Empty socket is a dark recessed well.</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.42</span>, <span class="n">0.44</span>, <span class="n">0.40</span>), rough=<span class="n">0.32</span>, metallic=<span class="n">0.88</span>)
-    sock_m = make_material(<span class="s">&quot;Socket&quot;</span>, (<span class="n">0.06</span>, <span class="n">0.07</span>, <span class="n">0.08</span>), rough=<span class="n">0.7</span>, metallic=<span class="n">0.2</span>)
-    sock_empty_m = make_material(
-        <span class="s">&quot;SocketEmpty&quot;</span>, (<span class="n">0.015</span>, <span class="n">0.018</span>, <span class="n">0.02</span>), rough=<span class="n">0.95</span>, metallic=<span class="n">0.0</span>,
-    )
-
-    <span class="k">def</span> make_prop(name, loc, rot_z=<span class="n">0.0</span>):
-        me = build_pedestal_mesh()
-        me.materials.append(body_m)
-        <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(name, me)
-        ob.scale = (<span class="n">1.15</span>, <span class="n">0.92</span>, <span class="n">1.08</span>)
+    <span class="k">def</span> make_prop(name, loc, rot_z):
+        ob = bpy.data.objects.new(name, build_pedestal_mesh(name))
+        ob.scale = PROP_SCALE
         ob.location = loc
         sc.collection.objects.link(ob)
-        bpy.context.view_layer.update()
-        apply_scale_data_api(ob)
-        bpy.context.view_layer.update()
-        origin_to_base_center(ob)
-        bpy.context.view_layer.update()
-        wb = world_bbox(ob)
-        ob.location.z -= wb[<span class="n">0</span>].z
+        bake_prop(ob)
+        <span class="c"># Sit the baked base on the floor and turn it to its placement.</span>
+        ob.location = loc
         ob.rotation_euler.z = rot_z
         bpy.context.view_layer.update()
         <span class="k">return</span> ob
 
-    <span class="k">def</span> make_acc(name, world_loc, mat):
-        me = build_accessory_mesh()
-        me.materials.append(mat)
-        ob = bpy.data.objects.new(name, me)
-        ob.location = world_loc
-        sc.collection.objects.link(ob)
-        <span class="k">return</span> ob
-
-    <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
+    <span class="k">def</span> seat_conduit(name, prop):
+        ob = bpy.data.objects.new(name, build_accessory_mesh(name))
+        ob.matrix_world = prop.matrix_world @ Matrix.Translation(MOUNT)
         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">55</span>))
-    right = make_prop(<span class="s">&quot;KeepProp&quot;</span>, (<span class="n">2.2</span>, <span class="n">0.0</span>, <span class="n">0.0</span>), rot_z=math.radians(-<span class="n">10</span>))
-
-    bpy.context.view_layer.update()
-    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>))
+    <span class="c"># Both stand on a kerbed sidewalk slab, so their origins sit SLAB_H above</span>
+    <span class="c"># the studio floor: the bare parent&#x27;s doubled translation lifts the</span>
+    <span class="c"># stranded elbow off the slab instead of sliding it along the floor.</span>
+    slab_me = bpy.data.meshes.new(<span class="s">&quot;Sidewalk&quot;</span>)
+    bm = bmesh.new()
+    <span class="k">try</span>:
+        box(bm, (-<span class="n">0.2</span>, <span class="n">0.15</span>, SLAB_H / <span class="n">2</span>), (<span class="n">3.3</span>, <span class="n">1.8</span>, SLAB_H), <span class="n">0</span>, bevel=<span class="n">0.02</span>)
+        bm.to_mesh(slab_me)
+    <span class="k">finally</span>:
+        bm.free()
+    slab_me.materials.append(make_material(<span class="s">&quot;Paving&quot;</span>, (<span class="n">0.035</span>, <span class="n">0.035</span>, <span class="n">0.038</span>), rough=<span class="n">0.9</span>,
+                                           metallic=<span class="n">0.0</span>))
+    slab = bpy.data.objects.new(<span class="s">&quot;Sidewalk&quot;</span>, slab_me)
+    sc.collection.objects.link(slab)
 
-    trap_sock = make_socket(<span class="s">&quot;TrapSocket&quot;</span>, left_front, sock_empty_m, parent=left)
-    keep_sock = make_socket(<span class="s">&quot;KeepSocket&quot;</span>, right_front, sock_m, parent=right)
+    keep = make_prop(<span class="s">&quot;Pedestal.Keep&quot;</span>, Vector((-<span class="n">0.95</span>, <span class="n">0.35</span>, SLAB_H)), math.radians(-<span class="n">18</span>))
+    trap = make_prop(<span class="s">&quot;Pedestal.Trap&quot;</span>, Vector((<span class="n">0.62</span>, <span class="n">0.05</span>, SLAB_H)), math.radians(-<span class="n">12</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.05</span>, <span class="n">0.0</span>)), acc_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.05</span>, <span class="n">0.0</span>)), acc_m)
-    trap_acc.scale = (<span class="n">1.55</span>, <span class="n">1.55</span>, <span class="n">1.55</span>)
-    keep_acc.scale = (<span class="n">1.55</span>, <span class="n">1.55</span>, <span class="n">1.55</span>)
+    keep_acc = seat_conduit(<span class="s">&quot;Conduit.Keep&quot;</span>, keep)
+    parent_keep_world(keep_acc, keep)
     bpy.context.view_layer.update()
 
-    w_before = trap_acc.matrix_world.translation.copy()
-    trap_acc.parent = left
+    trap_acc = seat_conduit(<span class="s">&quot;Conduit.Trap&quot;</span>, trap)
+    seat_world = trap_acc.matrix_world.copy()
+    trap_acc.parent = trap  <span class="c"># bare — the trap</span>
     bpy.context.view_layer.update()
-    jumped = (trap_acc.matrix_world.translation - w_before).length
     jumped_world = trap_acc.matrix_world.copy()
+    jumped = (jumped_world.translation - seat_world.translation).length
+    <span class="c"># Freeze the teleported pose so the still does not depend on the parent.</span>
     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"> </span><span class="s">&quot;</span>
-        <span class="s">f&quot;</span><span class="s">sock_at=</span>{tuple(round(c, <span class="n">3</span>) <span class="k">for</span> c <span class="k">in</span> left_front)}<span class="s"> </span><span class="s">&quot;</span>
-        <span class="s">f&quot;</span><span class="s">sep=</span>{(trap_acc.matrix_world.translation - left_front).length:<span class="s">.4f</span>}<span class="s">&quot;</span>
-    )
-
-    parent_keep_world(keep_acc, right)
-    bpy.context.view_layer.update()
-
-    origin_marker(sc, Vector(left.matrix_world.translation))
-    origin_marker(sc, Vector(right.matrix_world.translation))
-
-    <span class="c"># Big enough to read at card size; at 0.11 they vanished in the thumbnail.</span>
-    p_trap = placard(sc, <span class="s">&quot;TRAP&quot;</span>, (<span class="n">0.1</span>, -<span class="n">1.2</span>, <span class="n">0.02</span>), size=<span class="n">0.21</span>)
-    p_keep = placard(sc, <span class="s">&quot;MPI KEEP&quot;</span>, (<span class="n">2.15</span>, -<span class="n">1.2</span>, <span class="n">0.02</span>), size=<span class="n">0.21</span>)
+    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">seat=</span>{tuple(round(c, <span class="n">3</span>) <span class="k">for</span> c <span class="k">in</span> seat_world.translation)}<span class="s"> </span><span class="s">&quot;</span>
+          <span class="s">f&quot;</span><span class="s">landed=</span>{tuple(round(c, <span class="n">3</span>) <span class="k">for</span> c <span class="k">in</span> jumped_world.translation)}<span class="s">&quot;</span>)
+
+    ghost_m = make_material(<span class="s">&quot;SeatGhost&quot;</span>, (<span class="n">0.2</span>, <span class="n">0.75</span>, <span class="n">1.0</span>), rough=<span class="n">0.5</span>, metallic=<span class="n">0.0</span>,
+                            emit=(<span class="n">0.25</span>, <span class="n">0.8</span>, <span class="n">1.0</span>), estr=<span class="n">3.0</span>)
+    ghost = bpy.data.objects.new(<span class="s">&quot;Conduit.Trap.Seat&quot;</span>, trap_acc.data)
+    ghost.matrix_world = seat_world
+    sc.collection.objects.link(ghost)
+    ghost = ghost_of(sc, ghost, <span class="s">&quot;SeatOutline&quot;</span>, ghost_m)
+    bpy.data.objects.remove(bpy.data.objects[<span class="s">&quot;Conduit.Trap.Seat&quot;</span>])
+
+    pmats = [
+        make_material(<span class="s">&quot;PivotX&quot;</span>, (<span class="n">0.9</span>, <span class="n">0.08</span>, <span class="n">0.06</span>), rough=<span class="n">0.4</span>, metallic=<span class="n">0.0</span>,
+                      emit=(<span class="n">0.9</span>, <span class="n">0.08</span>, <span class="n">0.06</span>), estr=<span class="n">0.4</span>),
+        make_material(<span class="s">&quot;PivotY&quot;</span>, (<span class="n">0.25</span>, <span class="n">0.85</span>, <span class="n">0.08</span>), rough=<span class="n">0.4</span>, metallic=<span class="n">0.0</span>,
+                      emit=(<span class="n">0.25</span>, <span class="n">0.85</span>, <span class="n">0.08</span>), estr=<span class="n">0.4</span>),
+        make_material(<span class="s">&quot;PivotRing&quot;</span>, (<span class="n">0.6</span>, <span class="n">0.5</span>, <span class="n">0.36</span>), rough=<span class="n">0.5</span>, metallic=<span class="n">0.0</span>,
+                      emit=(<span class="n">1.0</span>, <span class="n">0.78</span>, <span class="n">0.5</span>), estr=<span class="n">0.12</span>),
+    ]
+    markers = [
+        pivot_marker(sc, <span class="s">&quot;Pivot.Keep&quot;</span>, keep.matrix_world.translation, keep.rotation_euler.z,
+                     pmats, <span class="n">0.72</span>),
+        pivot_marker(sc, <span class="s">&quot;Pivot.Trap&quot;</span>, trap.matrix_world.translation, trap.rotation_euler.z,
+                     pmats, <span class="n">0.72</span>),
+    ]
 
     floor, wall = build_studio(sc)
 
     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">56.0</span>
     cam = bpy.data.objects.new(<span class="s">&quot;Cam&quot;</span>, cam_data)
-    <span class="c"># Pulled back until the framing gate&#x27;s margins clear — not further.</span>
-    cam.location = (<span class="n">1.15</span>, -<span class="n">5.9</span>, <span class="n">1.55</span>)
+    cam.location = (<span class="n">1.1</span>, -<span class="n">5.6</span>, <span class="n">2.05</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">1.1</span>, <span class="n">0.0</span>, <span class="n">0.72</span>)
+    aim.location = (<span class="n">0.2</span>, <span class="n">0.1</span>, <span class="n">0.66</span>)
     sc.collection.objects.link(aim)
     tr = cam.constraints.new(<span class="s">&quot;TRACK_TO&quot;</span>)
     tr.target = aim
@@ -902,19 +1044,23 @@ <h2>Source</h2>
     sc.render.resolution_y = <span class="n">720</span>
     sc.render.image_settings.file_format = <span class="s">&quot;PNG&quot;</span>
     sc.render.filepath = path
+    <span class="c"># Standard, not AgX: AgX pales the paint and conduit and lifts the stage.</span>
     sc.view_settings.view_transform = <span class="s">&quot;Standard&quot;</span>
     <span class="c"># Layer 1 framing gate (silhouette matte) — exit 10 on violation, before</span>
     <span class="c"># the beauty render so a defective composition ships no artifact.</span>
-    hero = [left, right, trap_acc, keep_acc, trap_sock, keep_sock]
-    markers = [o <span class="k">for</span> o <span class="k">in</span> sc.objects <span class="k">if</span> o.name.startswith((<span class="s">&quot;OriginBead&quot;</span>, <span class="s">&quot;Axis&quot;</span>))]
+    hero = [keep, trap, keep_acc, trap_acc]
     fcode = gallery_framing.check_framing(
         sc, cam,
         hero=hero,
-        elements=hero + [p_trap, p_keep] + markers,
-        stage=[floor, wall],
+        elements=hero + [ghost] + markers,
+        stage=[floor, wall, slab],
     )
     <span class="k">if</span> fcode:
         <span class="k">return</span> fcode
+    aqcode = gallery_asset_quality.check_asset_quality(
+        sc, cam, hero=[keep, keep_acc], stage=[floor, wall, slab])
+    <span class="k">if</span> aqcode:
+        <span class="k">return</span> aqcode
     bpy.ops.render.render(write_still=<span class="k">True</span>)
     <span class="k">if</span> <span class="k">not</span> (os.path.exists(path) <span class="k">and</span> os.path.getsize(path) &gt; <span class="n">0</span>):
         print(<span class="s">&quot;ERROR: render produced no file&quot;</span>, file=sys.stderr)
@@ -961,7 +1107,7 @@ <h2>Source</h2>
   </main>
   <dialog class="lightbox" id="lightbox" aria-label="Full-size render">
     <button class="lightbox-close" type="button" autofocus>Close</button>
-    <img src="../assets/prop-origin-transform-hero.webp" alt="Two teal pedestals labelled TRAP and MPI KEEP, origin axes crossing on the floor under each base: on the left a conduit fitting has jumped out of its socket, on the right it sits seated." />
+    <img src="../assets/prop-origin-transform-hero.webp" alt="Two green street utility pedestals in floor pivot rings: the left one keeps its orange conduit elbow bolted on, the right one&#x27;s elbow hangs in the air beside a glowing cyan outline of its seat." />
   </dialog>
   <footer>
     <div class="statusbar">
diff --git a/examples/gallery.json b/examples/gallery.json
index 46f291a7..97abdccf 100644
--- a/examples/gallery.json
+++ b/examples/gallery.json
@@ -501,8 +501,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 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.",
-      "alt": "Two teal pedestals labelled TRAP and MPI KEEP, origin axes crossing on the floor under each base: on the left a conduit fitting has jumped out of its socket, on the right it sits seated.",
+      "teaches": "Street pedestal origin-to-base-center + data-API scale apply + matrix_parent_inverse for a flanged conduit elbow. After bake: scale (1,1,1), local min.z==0, world AABB unchanged. Bare parent throws the elbow off its mount; MPI keeps it seated.",
+      "alt": "Two green street utility pedestals in floor pivot rings: the left one keeps its orange conduit elbow bolted on, the right one's elbow hangs in the air beside a glowing cyan outline of its seat.",
       "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",
diff --git a/examples/prop-origin-transform/README.md b/examples/prop-origin-transform/README.md
index b9549aec..9412ad7a 100644
--- a/examples/prop-origin-transform/README.md
+++ b/examples/prop-origin-transform/README.md
@@ -1,7 +1,7 @@
 # Prop Origin Transform
 
-A runnable example that builds a street utility pedestal with a bolted
-conduit accessory and proves the **origin / scale-apply / MPI** contract a
+A runnable example that builds a street utility pedestal with a flanged
+conduit elbow and proves the **origin / scale-apply / MPI** contract a
 prop pipeline relies on before engine ingest — following
 [`operators`](../../skills/operators/SKILL.md) and the data-API parenting
 idiom from [`parent-inverse-orrery`](../parent-inverse-orrery/).
@@ -27,24 +27,37 @@ engine exporter — it proves the transform properties such an asset must have.
 - **Origin at base center.** Local bbox `min.z == 0`, XY centered; world AABB
   delta across the bake is **0** (gate `1e-5`).
 - **Bare-parent trap.** Parenting the accessory without MPI jumps it
-  (~0.43 m measured); setting `matrix_parent_inverse` restores world location
-  (err ~3e-8).
+  (0.298 m measured); setting `matrix_parent_inverse` restores world
+  location (err 0).
 
 **What each check catches on failure:** skipping scale apply leaves
-non-identity scale; skipping origin bake leaves `min.z ≈ -0.756`; skipping
-MPI leaves the accessory teleported.
+`(1.15, 0.92, 1.08)` (exit 5); skipping the origin bake leaves
+`min.z = -0.58` (exit 6); skipping MPI leaves the accessory 0.298 m off
+(exit 8).
 
-**Version witness:** byte-identical numbers on Blender 4.5.11 LTS and 5.1.2.
+**Version witness:** identical numbers on Blender 5.2.1 LTS, 5.1.2 and
+4.5.11 LTS.
 
-The render is a dual panel: left **TRAP** (bare parent — flanged conduit
-teleports off a deep shadowed mount socket) vs right **MPI KEEP** (same metal
-fitting seated in the socket), with emissive origin markers at each pedestal's
-base. The origin is inside the plinth, so the red X and green Y stubs are
-centred on it and run 1.7 m along the floor, exiting the plinth on both
-sides: where they cross, under the base, is the origin. The first cut drew
-0.28 m stubs from the origin outward, all buried, and 0.11 m labels that
-vanished at card size; the labels are 0.21 m now. Accessory and pedestal stay in one material family so displacement — not
-color — carries the proof. Check closed forms are unchanged.
+**The asset.** The pedestal is one mesh with five materials: a precast concrete footing,
+a galvanised base plate with anchor nuts, a green cabinet on a black kick
+skirt, a hipped lid, a door with hinges, a T-handle and a hazard plate, louvred
+side vents, a conduit boss on the +X face and a sleeve in the pad. It is
+authored the way an import often arrives: origin at the geometric centre and
+coordinates divided by a non-uniform object scale. The bake lands it on
+exactly the designed shape. The accessory is a flanged PVC conduit elbow
+with bolt heads, a strap clamp and a coupling that drops into the sleeve.
+
+**The render.** Two baked pedestals stand on a sidewalk slab. On the left the elbow is
+parented with MPI and stays bolted to its boss, seated in the sleeve. On the
+right, bare `child.parent = parent` applies the pedestal's transform a
+second time. The elbow is thrown 0.65 m, past the slab edge and into the
+air, and a glowing cyan outline (a Wireframe modifier on a copy)
+marks the seat it left. The slab raises both origins 0.20 m, so the doubled
+translation lifts the elbow instead of sliding it along the floor. A
+pivot ring on the floor is centred on each pedestal's origin, with red
+notches on its X axis and green notches on Y. The origin is under the base,
+so the ring frames it. There are no text labels: the ghost and the stranded
+elbow carry the proof. The check's closed forms are unchanged.
 
 ## Run
 
@@ -73,6 +86,7 @@ against it. `10` is the shared framing helper.
 | 8 | MPI did not restore world location (`--skip-mpi` lands here) |
 | 9 | `--output` produced no file |
 | 10 | Gallery framing violation |
+| 11 | Gallery asset-quality violation (render path only) |
 
 The `blender-smoke` workflow runs the check on Blender 5.2 LTS and 4.5 LTS
 (5.1 on the weekly cron, the `needs-5.1` PR label, or manual dispatch).
diff --git a/examples/prop-origin-transform/preview.webp b/examples/prop-origin-transform/preview.webp
index 9319faf3..02f143f8 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 9123a60b..72530523 100644
--- a/examples/prop-origin-transform/prop_origin_transform.py
+++ b/examples/prop-origin-transform/prop_origin_transform.py
@@ -5,7 +5,7 @@
 to exactly (1,1,1), world bbox unchanged across the bake, and
 `matrix_parent_inverse` so a parented accessory does not teleport. Extends
 `parent-inverse-orrery` (MPI idiom + stale `matrix_world`) without retreading
-orbits — subject is a street utility pedestal with a bolted conduit accessory.
+orbits — subject is a street utility pedestal with a flanged conduit elbow.
 
 ``--skip-mpi`` parents the accessory without MPI and still asserts the restore.
 That is the falsifier (``--same-axis`` in export-preset-axis).
@@ -20,10 +20,11 @@
 import bpy, bmesh, sys, os, math, argparse
 from mathutils import Matrix, Vector
 
-# Shared Layer 1 framing measurement (render path only) — see gallery_framing.py
+# Shared Layer 1 measurement (render path only) — see gallery_framing.py
 sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir))
 sys.dont_write_bytecode = True  # keep examples/__pycache__ out of the repo tree
 import gallery_framing
+import gallery_asset_quality
 
 BBOX_EPS = 1e-6
 WORLD_EPS = 1e-5
@@ -31,6 +32,25 @@
 STALE_EPS = 1e-9
 JUMP_MIN = 0.05
 
+# The pedestal arrives the way an import often does: origin at the geometric
+# centre and a non-uniform object scale compensating mesh data authored in
+# the wrong units. The bake must land the mesh on exactly the designed shape.
+PROP_SCALE = (1.15, 0.92, 1.08)
+
+# Designed dimensions (metres, base-centre origin).
+PAD = (1.04, 0.62, 0.10)            # precast concrete footing
+BODY_XY = (0.46, 0.36)
+BODY_Z = (0.125, 1.05)
+MOUNT_Z = 0.45                       # conduit boss on the +X side face
+MOUNT = Vector((BODY_XY[0] / 2 + 0.012, 0.0, MOUNT_Z))   # flange seat face
+SLEEVE = Vector((0.41, 0.0, PAD[2]))  # pad sleeve the conduit drops into
+SLEEVE_H = 0.05
+SLAB_H = 0.20                       # render only: sidewalk slab under both copies
+
+# Material slots
+M_PAINT, M_GALV, M_CONCRETE, M_DARK, M_LABEL = range(5)
+A_PVC, A_GALV = range(2)
+
 
 def eevee_engine_id():
     return "BLENDER_EEVEE" if bpy.app.version >= (5, 0, 0) else "BLENDER_EEVEE_NEXT"
@@ -50,6 +70,260 @@ def make_material(name, rgb, rough=0.45, metallic=0.35, emit=None, estr=0.0):
     return mat
 
 
+def pedestal_materials(tag=""):
+    return [
+        make_material(f"PedestalPaint{tag}", (0.05, 0.36, 0.20), rough=0.42, metallic=0.15),
+        make_material(f"GalvSteel{tag}", (0.62, 0.64, 0.66), rough=0.32, metallic=0.85),
+        make_material(f"Concrete{tag}", (0.36, 0.35, 0.33), rough=0.88, metallic=0.0),
+        make_material(f"BlackRubber{tag}", (0.025, 0.026, 0.028), rough=0.55, metallic=0.0),
+        make_material(f"HazardLabel{tag}", (0.95, 0.66, 0.02), rough=0.45, metallic=0.0),
+    ]
+
+
+def conduit_materials(tag=""):
+    return [
+        make_material(f"ConduitPVC{tag}", (0.92, 0.30, 0.03), rough=0.38, metallic=0.0),
+        make_material(f"ConduitGalv{tag}", (0.62, 0.64, 0.66), rough=0.32, metallic=0.85),
+    ]
+
+
+# ---------------------------------------------------------------------------
+# Modelling. Every part is built in one bmesh; each helper tags the faces it
+# creates with a material slot and a shading mode.
+
+
+class Part:
+    """Context for one part: new verts/faces are the set difference."""
+
+    def __init__(self, bm):
+        self.bm = bm
+        self.v0 = set(bm.verts)
+        self.f0 = set(bm.faces)
+
+    def verts(self):
+        return [v for v in self.bm.verts if v not in self.v0]
+
+    def finish(self, mat, smooth_axis=None):
+        for f in self.bm.faces:
+            if f in self.f0:
+                continue
+            f.material_index = mat
+            if smooth_axis is None:
+                f.smooth = False
+            else:
+                f.normal_update()
+                f.smooth = abs(f.normal.dot(smooth_axis)) < 0.9
+
+
+def box(bm, center, size, mat, bevel=0.0, rot=None):
+    part = Part(bm)
+    geom = bmesh.ops.create_cube(bm, size=1.0)
+    for v in geom["verts"]:
+        v.co = Vector((v.co.x * size[0], v.co.y * size[1], v.co.z * size[2]))
+    if bevel > 0.0:
+        edges = list({e for v in geom["verts"] for e in v.link_edges})
+        bmesh.ops.bevel(
+            bm, geom=edges, offset=bevel, segments=2, profile=0.5, affect="EDGES",
+            clamp_overlap=True,
+        )
+    m = Matrix.Translation(Vector(center))
+    if rot is not None:
+        m = m @ rot
+    bmesh.ops.transform(bm, matrix=m, verts=part.verts())
+    part.finish(mat)
+
+
+def _axis_matrix(axis):
+    """Rotation taking +Z onto *axis* (a unit Vector)."""
+    return Vector((0.0, 0.0, 1.0)).rotation_difference(axis).to_matrix().to_4x4()
+
+
+def cyl(bm, start, axis, length, r0, r1, mat, segs=24, smooth=True, bevel=0.0):
+    """Frustum from *start* along unit *axis*, radius r0 -> r1."""
+    part = Part(bm)
+    axis = Vector(axis).normalized()
+    geom = bmesh.ops.create_cone(
+        bm, cap_ends=True, cap_tris=False, segments=segs,
+        radius1=r0, radius2=r1, depth=length,
+    )
+    if bevel > 0.0:
+        # Chamfer the two cap rims so machined parts catch a highlight.
+        rims = [e for e in {e for v in geom["verts"] for e in v.link_edges}
+                if abs(e.verts[0].co.z - e.verts[1].co.z) < 1e-9]
+        bmesh.ops.bevel(
+            bm, geom=rims, offset=bevel, segments=2, profile=0.5, affect="EDGES",
+            clamp_overlap=True,
+        )
+    mat4 = Matrix.Translation(Vector(start) + axis * (length * 0.5)) @ _axis_matrix(axis)
+    bmesh.ops.transform(bm, matrix=mat4, verts=part.verts())
+    part.finish(mat, axis if smooth else None)
+
+
+def frustum_box(bm, z0, z1, lo, hi, mat):
+    """Hip lid: rectangle *lo* (x,y) at z0 rising to rectangle *hi* at z1."""
+    part = Part(bm)
+    ring = []
+    for (hx, hy), z in ((lo, z0), (hi, z1)):
+        ring.append([bm.verts.new((sx * hx / 2, sy * hy / 2, z))
+                     for sx, sy in ((-1, -1), (1, -1), (1, 1), (-1, 1))])
+    a, b = ring
+    for k in range(4):
+        n = (k + 1) % 4
+        bm.faces.new((a[k], a[n], b[n], b[k]))
+    bm.faces.new((a[0], a[3], a[2], a[1]))
+    bm.faces.new((b[0], b[1], b[2], b[3]))
+    part.finish(mat)
+
+
+def elbow(bm, start, radius, bend_r, mat, segs=20, steps=10):
+    """Quarter bend from *start* heading +X, turning down to -Z (XZ plane)."""
+    part = Part(bm)
+    rings = []
+    for i in range(steps + 1):
+        a = (math.pi / 2) * i / steps
+        c = Vector(start) + Vector((bend_r * math.sin(a), 0.0, -bend_r + bend_r * math.cos(a)))
+        t = Vector((math.cos(a), 0.0, -math.sin(a)))
+        n = t.cross(Vector((0.0, 1.0, 0.0))).normalized()  # in-plane normal
+        b = Vector((0.0, 1.0, 0.0))
+        rings.append([bm.verts.new(c + radius * (math.cos(2 * math.pi * k / segs) * n
+                                                 + math.sin(2 * math.pi * k / segs) * b))
+                      for k in range(segs)])
+    for r0, r1 in zip(rings, rings[1:]):
+        for k in range(segs):
+            m = (k + 1) % segs
+            f = bm.faces.new((r0[k], r0[m], r1[m], r1[k]))
+    part.finish(mat)
+    for f in bm.faces:
+        if f not in part.f0:
+            f.smooth = True
+
+
+def build_pedestal_design(bm):
+    """Street utility pedestal, designed shape, origin at the base centre."""
+    up = (0.0, 0.0, 1.0)
+    # Precast footing and the galvanised base plate with four anchor nuts.
+    box(bm, (0, 0, PAD[2] / 2), PAD, M_CONCRETE, bevel=0.025)
+    box(bm, (0, 0, PAD[2] + 0.0125), (0.58, 0.46, 0.025), M_GALV, bevel=0.006)
+    for sx in (-1, 1):
+        for sy in (-1, 1):
+            c = Vector((sx * 0.25, sy * 0.19, PAD[2] + 0.025))
+            cyl(bm, c, up, 0.006, 0.026, 0.026, M_GALV, segs=16)
+            cyl(bm, c + Vector((0, 0, 0.006)), up, 0.02, 0.019, 0.019, M_DARK,
+                segs=6, smooth=False)
+            cyl(bm, c + Vector((0, 0, 0.026)), up, 0.012, 0.008, 0.006, M_GALV, segs=10)
+    # Cabinet body over a black kick skirt.
+    zc = 0.5 * (BODY_Z[0] + BODY_Z[1])
+    box(bm, (0, 0, zc), (BODY_XY[0], BODY_XY[1], BODY_Z[1] - BODY_Z[0]), M_PAINT,
+        bevel=0.022)
+    box(bm, (0, 0, BODY_Z[0] + 0.045), (BODY_XY[0] + 0.02, BODY_XY[1] + 0.02, 0.09),
+        M_DARK, bevel=0.01)
+    # Overhanging lid with a hipped cap.
+    box(bm, (0, 0, BODY_Z[1] + 0.02), (0.52, 0.42, 0.04), M_PAINT, bevel=0.012)
+    frustum_box(bm, BODY_Z[1] + 0.04, BODY_Z[1] + 0.11, (0.50, 0.40), (0.30, 0.20),
+                M_PAINT)
+    # Front access door: dark shadow gap, raised panel, hinges, T-handle lock.
+    fy = -BODY_XY[1] / 2
+    box(bm, (0, fy - 0.002, 0.60), (0.37, 0.006, 0.70), M_DARK, bevel=0.002)
+    box(bm, (0, fy - 0.009, 0.60), (0.35, 0.012, 0.68), M_PAINT, bevel=0.005)
+    for z in (0.36, 0.84):
+        cyl(bm, (-0.182, fy - 0.012, z - 0.04), up, 0.08, 0.009, 0.009, M_GALV, segs=12)
+    cyl(bm, (0.12, fy - 0.015, 0.62), (0, -1, 0), 0.014, 0.022, 0.022, M_GALV, segs=20,
+        bevel=0.003)
+    box(bm, (0.12, fy - 0.034, 0.62), (0.018, 0.012, 0.10), M_GALV, bevel=0.004)
+    # Hazard plate high on the door: black border, yellow face, black mark.
+    box(bm, (0, fy - 0.016, 0.87), (0.17, 0.003, 0.11), M_DARK, bevel=0.001)
+    box(bm, (0, fy - 0.018, 0.87), (0.155, 0.003, 0.095), M_LABEL, bevel=0.001)
+    cyl(bm, (0, fy - 0.0195, 0.862), (0, -1, 0), 0.002, 0.034, 0.034, M_DARK, segs=3,
+        smooth=False)
+    # Louvred vents high on both sides.
+    for sx in (-1, 1):
+        x = sx * BODY_XY[0] / 2
+        box(bm, (x + sx * 0.002, 0, 0.87), (0.006, 0.24, 0.17), M_DARK, bevel=0.001)
+        for i in range(5):
+            box(bm, (x + sx * 0.012, 0, 0.805 + i * 0.032), (0.022, 0.23, 0.012), M_PAINT,
+                bevel=0.003, rot=Matrix.Rotation(sx * math.radians(-35), 4, "Y"))
+    # Conduit boss on the +X face (the accessory's seat) and the pad sleeve.
+    cyl(bm, (BODY_XY[0] / 2, 0, MOUNT_Z), (1, 0, 0), MOUNT.x - BODY_XY[0] / 2, 0.108,
+        0.108, M_GALV, segs=32, bevel=0.003)
+    cyl(bm, SLEEVE, up, SLEEVE_H, 0.076, 0.076, M_GALV, segs=28, bevel=0.004)
+    cyl(bm, SLEEVE + Vector((0, 0, SLEEVE_H)), up, 0.002, 0.06, 0.06, M_DARK, segs=28)
+
+
+def build_pedestal_mesh(name="StreetPedestal"):
+    """Pedestal mesh in its as-imported state (see PROP_SCALE)."""
+    me = bpy.data.meshes.new(name)
+    bm = bmesh.new()
+    try:
+        build_pedestal_design(bm)
+        # Origin at the geometric centre, coordinates divided by the object
+        # scale the import will carry.
+        xs = [v.co.x for v in bm.verts]
+        ys = [v.co.y for v in bm.verts]
+        zs = [v.co.z for v in bm.verts]
+        c = Vector((0.5 * (min(xs) + max(xs)), 0.5 * (min(ys) + max(ys)),
+                    0.5 * (min(zs) + max(zs))))
+        for v in bm.verts:
+            p = v.co - c
+            v.co = Vector((p.x / PROP_SCALE[0], p.y / PROP_SCALE[1], p.z / PROP_SCALE[2]))
+        bm.normal_update()
+        bm.to_mesh(me)
+    finally:
+        bm.free()
+    for m in pedestal_materials():
+        me.materials.append(m)
+    return me
+
+
+def build_conduit_design(bm):
+    """Flanged conduit elbow. Origin at the flange's mounting face, +X out of
+    the pedestal, the drop leg ending in a coupling that seats in the sleeve."""
+    xa = Vector((1, 0, 0))
+    down = Vector((0, 0, -1))
+    r = 0.05                         # conduit outside radius
+    bend_r = 0.10
+    leg_x = SLEEVE.x - MOUNT.x
+    x_bend = leg_x - bend_r
+    z_seat = SLEEVE.z + SLEEVE_H - MOUNT.z
+    # Flange with four bolt heads.
+    cyl(bm, (0, 0, 0), xa, 0.02, 0.095, 0.095, A_GALV, segs=32, bevel=0.004)
+    for k in range(4):
+        a = math.radians(45 + 90 * k)
+        cyl(bm, (0.02, 0.068 * math.cos(a), 0.068 * math.sin(a)), xa, 0.012, 0.014,
+            0.014, A_GALV, segs=6, smooth=False)
+    # Hub, horizontal run, bend, drop leg.
+    cyl(bm, (0.02, 0, 0), xa, 0.03, r + 0.012, r + 0.012, A_PVC, segs=28, bevel=0.004)
+    cyl(bm, (0.05, 0, 0), xa, x_bend - 0.05, r, r, A_PVC, segs=28)
+    elbow(bm, (x_bend, 0, 0), r, bend_r, A_PVC, segs=28)
+    leg_top = Vector((leg_x, 0, -bend_r))
+    leg_len = (-bend_r) - (z_seat + 0.05)
+    cyl(bm, leg_top, down, leg_len, r, r, A_PVC, segs=28)
+    # Strap clamp mid-leg and the coupling that sits on the sleeve.
+    cyl(bm, leg_top + down * (leg_len * 0.45), down, 0.022, r + 0.008, r + 0.008, A_GALV,
+        segs=28, bevel=0.003)
+    box(bm, leg_top + down * (leg_len * 0.45 + 0.011) + Vector((0, r + 0.014, 0)),
+        (0.022, 0.024, 0.022), A_GALV, bevel=0.004)
+    cyl(bm, Vector((leg_x, 0, z_seat + 0.05)), down, 0.05, r + 0.012, r + 0.012, A_GALV,
+        segs=28, bevel=0.004)
+
+
+def build_accessory_mesh(name="ConduitElbow"):
+    me = bpy.data.meshes.new(name)
+    bm = bmesh.new()
+    try:
+        build_conduit_design(bm)
+        bm.normal_update()
+        bm.to_mesh(me)
+    finally:
+        bm.free()
+    for m in conduit_materials():
+        me.materials.append(m)
+    return me
+
+
+# ---------------------------------------------------------------------------
+# Contract
+
+
 def local_bbox(me):
     xs = [v.co.x for v in me.vertices]
     ys = [v.co.y for v in me.vertices]
@@ -82,112 +356,6 @@ def bbox_delta(a, b):
     )
 
 
-def build_pedestal_mesh():
-    """Stepped street pedestal mesh in local space (origin roughly at center)."""
-    rings = [
-        (0.55, 0.45, -0.70),
-        (0.55, 0.45, -0.52),
-        (0.42, 0.34, -0.52),
-        (0.42, 0.34, 0.55),
-        (0.48, 0.38, 0.55),
-        (0.48, 0.38, 0.70),
-    ]
-    me = bpy.data.meshes.new("Pedestal")
-    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 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, top = ring_verts[0], ring_verts[-1]
-        bm.faces.new((bot[0], bot[3], bot[2], bot[1]))
-        bm.faces.new((top[0], top[1], top[2], top[3]))
-        bmesh.ops.recalc_face_normals(bm, faces=bm.faces)
-        bm.to_mesh(me)
-    finally:
-        bm.free()
-    return me
-
-
-def build_accessory_mesh():
-    """Flanged conduit stub — short pipe + mounting flange + bolt heads."""
-    me = bpy.data.meshes.new("Conduit")
-    bm = bmesh.new()
-    try:
-        # Barrel along +Y (away from prop face when mounted); origin at flange face
-        barrel = bmesh.ops.create_cone(
-            bm, cap_ends=True, segments=16, radius1=0.09, radius2=0.08, depth=0.48,
-        )
-        bmesh.ops.rotate(
-            bm, verts=barrel["verts"], cent=(0, 0, 0),
-            matrix=Matrix.Rotation(math.radians(90), 4, "X"),
-        )
-        bmesh.ops.translate(bm, vec=(0.0, -0.24, 0.0), verts=barrel["verts"])
-        # Thick mounting flange at the prop-facing (+Y local before rotate → y≈0)
-        flange = bmesh.ops.create_cone(
-            bm, cap_ends=True, segments=20, radius1=0.20, radius2=0.20, depth=0.06,
-        )
-        bmesh.ops.rotate(
-            bm, verts=flange["verts"], cent=(0, 0, 0),
-            matrix=Matrix.Rotation(math.radians(90), 4, "X"),
-        )
-        bmesh.ops.translate(bm, vec=(0.0, 0.03, 0.0), verts=flange["verts"])
-        # Four bolt heads on the flange face (camera-visible when seated)
-        for ang in (45, 135, 225, 315):
-            rad = math.radians(ang)
-            bx, bz = 0.14 * math.cos(rad), 0.14 * math.sin(rad)
-            br = bmesh.ops.create_cone(
-                bm, cap_ends=True, segments=8, radius1=0.032, radius2=0.032, depth=0.04,
-            )
-            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.07, bz), verts=br["verts"])
-        bm.to_mesh(me)
-    finally:
-        bm.free()
-    return me
-
-
-def build_socket_mesh():
-    """Deep mount well — shadowed interior reads as the vacated seat."""
-    me = bpy.data.meshes.new("Socket")
-    bm = bmesh.new()
-    try:
-        # Outer collar (matches flange OD)
-        bmesh.ops.create_cone(
-            bm, cap_ends=True, segments=24, radius1=0.24, radius2=0.24, depth=0.07,
-        )
-        # Deep dark well — into the prop after rotate
-        well = bmesh.ops.create_cone(
-            bm, cap_ends=True, segments=20, radius1=0.13, radius2=0.11, depth=0.18,
-        )
-        bmesh.ops.translate(bm, vec=(0.0, 0.0, -0.06), verts=well["verts"])
-        # Backstop disk (shadowed pocket floor)
-        floor = bmesh.ops.create_cone(
-            bm, cap_ends=True, segments=16, radius1=0.10, radius2=0.10, depth=0.025,
-        )
-        bmesh.ops.translate(bm, vec=(0.0, 0.0, -0.16), verts=floor["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()
-    return me
-
-
 def apply_scale_data_api(obj):
     """Bake non-uniform scale into mesh verts; leave obj.scale == (1,1,1)."""
     sx, sy, sz = obj.scale
@@ -224,22 +392,13 @@ def build_scene():
     bpy.ops.wm.read_factory_settings(use_empty=True)
     sc = bpy.context.scene
 
-    body_m = make_material("Body", (0.20, 0.38, 0.34), rough=0.42, metallic=0.55)
-    acc_m = make_material("Conduit", (0.45, 0.42, 0.28), rough=0.4, metallic=0.7)
-
-    me = build_pedestal_mesh()
-    me.materials.append(body_m)
-    for p in me.polygons:
-        p.use_smooth = False
-    prop = bpy.data.objects.new("StreetPedestal", me)
+    prop = bpy.data.objects.new("StreetPedestal", build_pedestal_mesh())
     # Intentionally wrong for ingest: non-uniform scale, origin at geometry center
-    prop.scale = (1.15, 0.92, 1.08)
+    prop.scale = PROP_SCALE
     prop.location = (0.0, 0.0, 0.0)
     sc.collection.objects.link(prop)
 
-    ame = build_accessory_mesh()
-    ame.materials.append(acc_m)
-    acc = bpy.data.objects.new("Accessory", ame)
+    acc = bpy.data.objects.new("ConduitElbow", build_accessory_mesh())
     # World pose before parenting — bolted to the front face mid-height
     acc.location = (0.0, -0.55, 0.15)
     acc.rotation_euler = (0.0, 0.0, 0.0)
@@ -365,68 +524,61 @@ def check(prop, acc, skip_mpi=False):
     return 0
 
 
-def origin_marker(sc, loc):
-    """Emissive triad at the object origin — scene evidence, not a light.
+# ---------------------------------------------------------------------------
+# Render
 
-    The origin sits at the base centre, inside the plinth, so a bead alone is
-    buried. The X and Y stubs are centred on it and run long enough to exit
-    the plinth on both sides along the floor: where they cross, under the
-    pedestal, is the origin.
-    """
-    mat = make_material(
-        "OriginMark", (1.0, 0.55, 0.1), rough=0.35, metallic=0.0,
-        emit=(1.0, 0.6, 0.1), estr=2.2,
-    )
-    me = bpy.data.meshes.new("OriginBead")
+
+def ghost_of(sc, src, name, mat):
+    """Glowing wire outline of *src* at its current world pose: where the
+    accessory belongs. A Wireframe modifier on a copy, every slot the ghost
+    material."""
+    me = src.data.copy()
+    me.name = name
+    for i in range(len(me.materials)):
+        me.materials[i] = mat
+    ob = bpy.data.objects.new(name, me)
+    ob.matrix_world = src.matrix_world.copy()
+    sc.collection.objects.link(ob)
+    wf = ob.modifiers.new("Outline", "WIREFRAME")
+    wf.thickness = 0.005
+    wf.use_replace = True
+    wf.use_even_offset = True
+    return ob
+
+
+def pivot_marker(sc, name, origin, rot_z, mats, reach):
+    """Floor pivot target centred on the object origin: a thin ring around
+    the footing with crosshair notches on the object's X and Y axes. The
+    origin itself is under the base, so the marker frames it."""
+    me = bpy.data.meshes.new(name)
     bm = bmesh.new()
     try:
-        bmesh.ops.create_uvsphere(bm, u_segments=10, v_segments=8, radius=0.09)
+        up = Vector((0, 0, 1))
+        part = Part(bm)
+        bmesh.ops.create_circle(bm, cap_ends=False, segments=96, radius=reach)
+        ring_edges = [e for e in bm.edges]
+        ext = bmesh.ops.extrude_edge_only(bm, edges=ring_edges)
+        nv = [g for g in ext["geom"] if isinstance(g, bmesh.types.BMVert)]
+        bmesh.ops.scale(bm, vec=(1 + 0.018 / reach, 1 + 0.018 / reach, 1), verts=nv)
+        bmesh.ops.translate(bm, vec=(0, 0, 0.003), verts=part.verts())
+        part.finish(2)
+        # Crosshair notches on the object's own X (red) and Y (green) axes:
+        # the lines they sight along cross at the origin, under the base.
+        for k in range(4):
+            a = k * math.pi / 2
+            d = Vector((math.cos(a), math.sin(a), 0.0))
+            mid = d * (reach - 0.05) + up * 0.006
+            box(bm, mid, (0.17, 0.028, 0.008), k % 2,
+                bevel=0.003, rot=Matrix.Rotation(a, 4, "Z"))
         bm.to_mesh(me)
     finally:
         bm.free()
-    me.materials.append(mat)
-    ob = bpy.data.objects.new("OriginBead", me)
-    ob.location = loc
-    sc.collection.objects.link(ob)
-    # Axis stubs
-    for axis, rgb, rot, depth in (
-        ("X", (1.0, 0.2, 0.15), (0, math.radians(90), 0), 1.7),
-        ("Y", (0.2, 1.0, 0.25), (math.radians(-90), 0, 0), 1.7),
-        ("Z", (0.25, 0.45, 1.0), (0, 0, 0), 0.56),
-    ):
-        ame = bpy.data.meshes.new(f"Axis{axis}")
-        abm = bmesh.new()
-        try:
-            bmesh.ops.create_cone(
-                abm, cap_ends=True, segments=8, radius1=0.022, radius2=0.022, depth=depth,
-            )
-            if axis == "Z":
-                bmesh.ops.translate(abm, vec=(0, 0, depth / 2.0), verts=abm.verts)
-            abm.to_mesh(ame)
-        finally:
-            abm.free()
-        am = make_material(
-            f"Axis{axis}", rgb, rough=0.4, metallic=0.0, emit=rgb, estr=1.5,
-        )
-        ame.materials.append(am)
-        aob = bpy.data.objects.new(f"Axis{axis}", ame)
-        # X and Y are centred on the origin, lifted one radius onto the floor
-        aob.location = loc + Vector((0.0, 0.0, 0.022 if axis != "Z" else 0.0))
-        aob.rotation_euler = rot
-        sc.collection.objects.link(aob)
-
-
-def placard(sc, text, loc, size=0.18):
-    cu = bpy.data.curves.new(text, "FONT")
-    cu.body = text
-    cu.size = size
-    cu.align_x = "CENTER"
-    cu.extrude = 0.006
-    ob = bpy.data.objects.new(text, cu)
-    ob.location = loc
+    for m in mats:
+        me.materials.append(m)
+    ob = bpy.data.objects.new(name, me)
+    ob.location = origin
+    ob.rotation_euler.z = rot_z
     sc.collection.objects.link(ob)
-    mat = make_material("Label", (0.92, 0.92, 0.94), rough=0.6, metallic=0.0)
-    ob.data.materials.append(mat)
     return ob
 
 
@@ -443,7 +595,7 @@ def build_studio(sc):
     floor = bpy.data.objects.new("Floor", floor_me)
     sc.collection.objects.link(floor)
     wall = bpy.data.objects.new("Wall", floor_me.copy())
-    wall.location = (0.0, 9.0, 0.0)
+    wall.location = (0.0, 7.0, 0.0)
     wall.rotation_euler = (math.radians(90), 0.0, 0.0)
     sc.collection.objects.link(wall)
 
@@ -454,129 +606,118 @@ def build_studio(sc):
     )
     sc.world = world
 
-    def light(name, loc, energy, size, col, rot):
+    def light(name, loc, energy, size, col, target):
         ld = bpy.data.lights.new(name, "AREA")
         ld.energy = energy
         ld.size = size
         ld.color = col
         ob = bpy.data.objects.new(name, ld)
         ob.location = loc
-        ob.rotation_euler = tuple(math.radians(a) for a in rot)
+        ob.rotation_euler = (Vector(target) - Vector(loc)).to_track_quat("-Z", "Y").to_euler()
         sc.collection.objects.link(ob)
 
-    light("Key", (-3.5, -4.5, 5.5), 480.0, 4.5, (1.0, 0.96, 0.9), (48, 0, -35))
-    light("Fill", (5.0, -3.5, 2.5), 120.0, 9.0, (0.75, 0.85, 1.0), (65, 0, 50))
-    light("Rim", (1.5, 4.5, 3.5), 280.0, 3.0, (0.6, 0.78, 1.0), (-55, 0, 170))
-    light("Wedge", (2.5, 5.5, 4.0), 400.0, 6.0, (1.0, 0.72, 0.42), (-68, 0, 190))
+    light("Key", (-3.0, -4.0, 5.0), 340.0, 3.0, (1.0, 0.86, 0.68), (0.2, 0, 0.6))
+    light("Fill", (4.5, -4.0, 2.2), 45.0, 8.0, (0.75, 0.85, 1.0), (0.2, 0, 0.6))
+    light("Rim", (1.0, 3.0, 4.2), 150.0, 2.5, (0.6, 0.78, 1.0), (0.2, 0, 1.0))
+    light("Wedge", (2.0, 4.0, 3.5), 380.0, 6.0, (1.0, 0.68, 0.36), (0.5, 7.0, 0.7))
     return floor, wall
 
 
 def render_still(path, engine):
-    """Dual panel: bare-parent TRAP (left) vs MPI KEEP (right) + origin at base."""
+    """Two baked pedestals. Left: the conduit parented with MPI stays seated.
+    Right: bare `child.parent = parent` double-applies the parent transform
+    and the elbow is left hanging off its mount, a glowing outline marking
+    the seat it left."""
     bpy.ops.wm.read_factory_settings(use_empty=True)
     sc = bpy.context.scene
 
-    # Teal pedestal — accessory shares metal fitting in the same family (no
-    # primary-color emission blobs). Empty socket is a dark recessed well.
-    body_m = make_material("BodyR", (0.14, 0.48, 0.42), rough=0.4, metallic=0.55)
-    acc_m = make_material("AccR", (0.42, 0.44, 0.40), rough=0.32, metallic=0.88)
-    sock_m = make_material("Socket", (0.06, 0.07, 0.08), rough=0.7, metallic=0.2)
-    sock_empty_m = make_material(
-        "SocketEmpty", (0.015, 0.018, 0.02), rough=0.95, metallic=0.0,
-    )
-
-    def make_prop(name, loc, rot_z=0.0):
-        me = build_pedestal_mesh()
-        me.materials.append(body_m)
-        for p in me.polygons:
-            p.use_smooth = False
-        ob = bpy.data.objects.new(name, me)
-        ob.scale = (1.15, 0.92, 1.08)
+    def make_prop(name, loc, rot_z):
+        ob = bpy.data.objects.new(name, build_pedestal_mesh(name))
+        ob.scale = PROP_SCALE
         ob.location = loc
         sc.collection.objects.link(ob)
-        bpy.context.view_layer.update()
-        apply_scale_data_api(ob)
-        bpy.context.view_layer.update()
-        origin_to_base_center(ob)
-        bpy.context.view_layer.update()
-        wb = world_bbox(ob)
-        ob.location.z -= wb[0].z
+        bake_prop(ob)
+        # Sit the baked base on the floor and turn it to its placement.
+        ob.location = loc
         ob.rotation_euler.z = rot_z
         bpy.context.view_layer.update()
         return ob
 
-    def make_acc(name, world_loc, mat):
-        me = build_accessory_mesh()
-        me.materials.append(mat)
-        ob = bpy.data.objects.new(name, me)
-        ob.location = world_loc
-        sc.collection.objects.link(ob)
-        return ob
-
-    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
+    def seat_conduit(name, prop):
+        ob = bpy.data.objects.new(name, build_accessory_mesh(name))
+        ob.matrix_world = prop.matrix_world @ Matrix.Translation(MOUNT)
         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(55))
-    right = make_prop("KeepProp", (2.2, 0.0, 0.0), rot_z=math.radians(-10))
-
-    bpy.context.view_layer.update()
-    left_front = left.matrix_world @ Vector((0.0, -0.52, 0.78))
-    right_front = right.matrix_world @ Vector((0.0, -0.52, 0.78))
+    # Both stand on a kerbed sidewalk slab, so their origins sit SLAB_H above
+    # the studio floor: the bare parent's doubled translation lifts the
+    # stranded elbow off the slab instead of sliding it along the floor.
+    slab_me = bpy.data.meshes.new("Sidewalk")
+    bm = bmesh.new()
+    try:
+        box(bm, (-0.2, 0.15, SLAB_H / 2), (3.3, 1.8, SLAB_H), 0, bevel=0.02)
+        bm.to_mesh(slab_me)
+    finally:
+        bm.free()
+    slab_me.materials.append(make_material("Paving", (0.035, 0.035, 0.038), rough=0.9,
+                                           metallic=0.0))
+    slab = bpy.data.objects.new("Sidewalk", slab_me)
+    sc.collection.objects.link(slab)
 
-    trap_sock = make_socket("TrapSocket", left_front, sock_empty_m, parent=left)
-    keep_sock = make_socket("KeepSocket", right_front, sock_m, parent=right)
+    keep = make_prop("Pedestal.Keep", Vector((-0.95, 0.35, SLAB_H)), math.radians(-18))
+    trap = make_prop("Pedestal.Trap", Vector((0.62, 0.05, SLAB_H)), math.radians(-12))
 
-    trap_acc = make_acc("TrapAcc", left_front + Vector((0.0, -0.05, 0.0)), acc_m)
-    keep_acc = make_acc("KeepAcc", right_front + Vector((0.0, -0.05, 0.0)), acc_m)
-    trap_acc.scale = (1.55, 1.55, 1.55)
-    keep_acc.scale = (1.55, 1.55, 1.55)
+    keep_acc = seat_conduit("Conduit.Keep", keep)
+    parent_keep_world(keep_acc, keep)
     bpy.context.view_layer.update()
 
-    w_before = trap_acc.matrix_world.translation.copy()
-    trap_acc.parent = left
+    trap_acc = seat_conduit("Conduit.Trap", trap)
+    seat_world = trap_acc.matrix_world.copy()
+    trap_acc.parent = trap  # bare — the trap
     bpy.context.view_layer.update()
-    jumped = (trap_acc.matrix_world.translation - w_before).length
     jumped_world = trap_acc.matrix_world.copy()
+    jumped = (jumped_world.translation - seat_world.translation).length
+    # Freeze the teleported pose so the still does not depend on the parent.
     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)} "
-        f"sock_at={tuple(round(c, 3) for c in left_front)} "
-        f"sep={(trap_acc.matrix_world.translation - left_front).length:.4f}"
-    )
-
-    parent_keep_world(keep_acc, right)
-    bpy.context.view_layer.update()
-
-    origin_marker(sc, Vector(left.matrix_world.translation))
-    origin_marker(sc, Vector(right.matrix_world.translation))
-
-    # Big enough to read at card size; at 0.11 they vanished in the thumbnail.
-    p_trap = placard(sc, "TRAP", (0.1, -1.2, 0.02), size=0.21)
-    p_keep = placard(sc, "MPI KEEP", (2.15, -1.2, 0.02), size=0.21)
+    print(f"render_trap_jump={jumped:.4f} "
+          f"seat={tuple(round(c, 3) for c in seat_world.translation)} "
+          f"landed={tuple(round(c, 3) for c in jumped_world.translation)}")
+
+    ghost_m = make_material("SeatGhost", (0.2, 0.75, 1.0), rough=0.5, metallic=0.0,
+                            emit=(0.25, 0.8, 1.0), estr=3.0)
+    ghost = bpy.data.objects.new("Conduit.Trap.Seat", trap_acc.data)
+    ghost.matrix_world = seat_world
+    sc.collection.objects.link(ghost)
+    ghost = ghost_of(sc, ghost, "SeatOutline", ghost_m)
+    bpy.data.objects.remove(bpy.data.objects["Conduit.Trap.Seat"])
+
+    pmats = [
+        make_material("PivotX", (0.9, 0.08, 0.06), rough=0.4, metallic=0.0,
+                      emit=(0.9, 0.08, 0.06), estr=0.4),
+        make_material("PivotY", (0.25, 0.85, 0.08), rough=0.4, metallic=0.0,
+                      emit=(0.25, 0.85, 0.08), estr=0.4),
+        make_material("PivotRing", (0.6, 0.5, 0.36), rough=0.5, metallic=0.0,
+                      emit=(1.0, 0.78, 0.5), estr=0.12),
+    ]
+    markers = [
+        pivot_marker(sc, "Pivot.Keep", keep.matrix_world.translation, keep.rotation_euler.z,
+                     pmats, 0.72),
+        pivot_marker(sc, "Pivot.Trap", trap.matrix_world.translation, trap.rotation_euler.z,
+                     pmats, 0.72),
+    ]
 
     floor, wall = build_studio(sc)
 
     cam_data = bpy.data.cameras.new("Cam")
-    cam_data.lens = 48.0
+    cam_data.lens = 56.0
     cam = bpy.data.objects.new("Cam", cam_data)
-    # Pulled back until the framing gate's margins clear — not further.
-    cam.location = (1.15, -5.9, 1.55)
+    cam.location = (1.1, -5.6, 2.05)
     sc.collection.objects.link(cam)
     aim = bpy.data.objects.new("Aim", None)
-    aim.location = (1.1, 0.0, 0.72)
+    aim.location = (0.2, 0.1, 0.66)
     sc.collection.objects.link(aim)
     tr = cam.constraints.new("TRACK_TO")
     tr.target = aim
@@ -598,19 +739,23 @@ def make_socket(name, world_loc, mat, parent=None):
     sc.render.resolution_y = 720
     sc.render.image_settings.file_format = "PNG"
     sc.render.filepath = path
+    # Standard, not AgX: AgX pales the paint and conduit and lifts the stage.
     sc.view_settings.view_transform = "Standard"
     # Layer 1 framing gate (silhouette matte) — exit 10 on violation, before
     # the beauty render so a defective composition ships no artifact.
-    hero = [left, right, trap_acc, keep_acc, trap_sock, keep_sock]
-    markers = [o for o in sc.objects if o.name.startswith(("OriginBead", "Axis"))]
+    hero = [keep, trap, keep_acc, trap_acc]
     fcode = gallery_framing.check_framing(
         sc, cam,
         hero=hero,
-        elements=hero + [p_trap, p_keep] + markers,
-        stage=[floor, wall],
+        elements=hero + [ghost] + markers,
+        stage=[floor, wall, slab],
     )
     if fcode:
         return fcode
+    aqcode = gallery_asset_quality.check_asset_quality(
+        sc, cam, hero=[keep, keep_acc], stage=[floor, wall, slab])
+    if aqcode:
+        return aqcode
     bpy.ops.render.render(write_still=True)
     if not (os.path.exists(path) and os.path.getsize(path) > 0):
         print("ERROR: render produced no file", file=sys.stderr)
diff --git a/scripts/asset_sheet.py b/scripts/asset_sheet.py
index 7ea96890..4fa8d6fe 100644
--- a/scripts/asset_sheet.py
+++ b/scripts/asset_sheet.py
@@ -69,6 +69,7 @@
     "car-mirror-symmetry": (r"^(CarBody|Wheel(Front|Rear)|Headlamp|Taillamp|Grille"
                             r"|DoorMirror|DoorHandle(Front|Rear))$", None),
     "export-preset-axis": (r"^RadioMast\.Unity$", None),
+    "prop-origin-transform": (r"^(Pedestal|Conduit)\.Keep$", None),
     "gltf-skin-roundtrip": (r"^ScorpionAuthored$", None),
 }