diff --git a/README.md b/README.md
index 06e64231..143d5e6a 100644
--- a/README.md
+++ b/README.md
@@ -1046,17 +1046,17 @@ smoothed render inverts on sight if the panel binding does.
 </tr>
 <tr>
 <td width="46%" valign="middle">
-<a href="examples/car-mirror-symmetry/"><img src="examples/car-mirror-symmetry/preview.webp" alt="Car mirror symmetry: a red low-poly hatchback on a dark studio floor, light windshield band and white headlamp pair — lofted as one half and completed by the Mirror modifier evaluated through the depsgraph, proving 2n-c counts, exact negated-X partners, a welded watertight centerline, and wheels mirrored about origins on the plane" /></a>
+<a href="examples/car-mirror-symmetry/"><img src="examples/car-mirror-symmetry/preview.webp" alt="Car mirror symmetry: a red stylized hatchback on a dark studio floor, tinted glass, black pillars and arch cladding, spoked wheels, and a matched headlamp and door-mirror pair either side of one centered grille — lofted as one half and completed by the Mirror modifier evaluated through the depsgraph, proving 2n-c counts, exact negated-X partners, a welded watertight centerline, and wheels mirrored about origins on the plane" /></a>
 </td>
 <td valign="middle">
 
 ### [car-mirror-symmetry](examples/car-mirror-symmetry/)
 
 The Mirror + depsgraph contract: the datablock holds only the authored half
-(126/231/106, 28 centerline verts) while the evaluated mesh is the welded
+(676/1289/614, 104 centerline verts) while the evaluated mesh is the welded
 whole — exactly `2n − c` verts, watertight with Euler 2, every vertex paired
-at negated X (deviation 0.0). Wheels and lamps mirror about object origins
-parked **on** the symmetry plane — offset the data, never the object.
+at negated X (deviation 0.0). Wheels, lamps, grille, mirrors and handles mirror
+about object origins parked **on** the symmetry plane — offset the data, never the object.
 Companion to [`depsgraph-export`](examples/depsgraph-export/) (evaluated-vs-
 original) and [`shape-key-blend`](examples/shape-key-blend/) (non-destructive
 evaluation). Break the mirror and the render is literally half a car.
diff --git a/docs/gallery/asset-sheets/car-mirror-symmetry.webp b/docs/gallery/asset-sheets/car-mirror-symmetry.webp
new file mode 100644
index 00000000..3dc9110b
Binary files /dev/null and b/docs/gallery/asset-sheets/car-mirror-symmetry.webp differ
diff --git a/docs/gallery/assets/car-mirror-symmetry-hero.webp b/docs/gallery/assets/car-mirror-symmetry-hero.webp
index 209f94d0..b3169840 100644
Binary files a/docs/gallery/assets/car-mirror-symmetry-hero.webp and b/docs/gallery/assets/car-mirror-symmetry-hero.webp differ
diff --git a/docs/gallery/car-mirror-symmetry/index.html b/docs/gallery/car-mirror-symmetry/index.html
index 2ec75a13..9a7ba07d 100644
--- a/docs/gallery/car-mirror-symmetry/index.html
+++ b/docs/gallery/car-mirror-symmetry/index.html
@@ -4,25 +4,25 @@
   <meta charset="utf-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1" />
   <title>car-mirror-symmetry — Examples — Blender Developer Tools</title>
-  <meta name="description" content="A generic hatchback lofted as one half (14 stations, 9-point rings) and completed by the Mirror modifier, evaluated through the depsgraph. Wheels and lamps mirror about object origins parked on the symmetry plane." />
+  <meta name="description" content="A stylized hatchback lofted as one half (52 stations, 13-point rings) and completed by the Mirror modifier, evaluated through the depsgraph. Wheels, lamps, grille, door mirrors and handles mirror about object origins parked on the symmetry plane; the grille is authored as a half and welded on it." />
   <link rel="canonical" href="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/car-mirror-symmetry/" />
   <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="car-mirror-symmetry — Examples — Blender Developer Tools" />
-  <meta property="og:description" content="A generic hatchback lofted as one half (14 stations, 9-point rings) and completed by the Mirror modifier, evaluated through the depsgraph. Wheels and lamps mirror about object origins parked on the symmetry plane." />
+  <meta property="og:description" content="A stylized hatchback lofted as one half (52 stations, 13-point rings) and completed by the Mirror modifier, evaluated through the depsgraph. Wheels, lamps, grille, door mirrors and handles mirror about object origins parked on the symmetry plane; the grille is authored as a half and welded on it." />
   <meta property="og:url" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/car-mirror-symmetry/" />
   <meta property="og:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/car-mirror-symmetry-hero.webp" />
   <meta property="og:image:width" content="1280" />
   <meta property="og:image:height" content="720" />
-  <meta property="og:image:alt" content="A red low-poly hatchback with white headlights, modelled as one mirrored half." />
+  <meta property="og:image:alt" content="A red stylized hatchback in front three-quarter view with tinted glass, black pillars, spoked wheels, and matched headlamps and door mirrors either side of one centered grille." />
   <meta property="og:site_name" content="Blender Developer Tools" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="car-mirror-symmetry — Examples — Blender Developer Tools" />
-  <meta name="twitter:description" content="A generic hatchback lofted as one half (14 stations, 9-point rings) and completed by the Mirror modifier, evaluated through the depsgraph. Wheels and lamps mirror about object origins parked on the symmetry plane." />
+  <meta name="twitter:description" content="A stylized hatchback lofted as one half (52 stations, 13-point rings) and completed by the Mirror modifier, evaluated through the depsgraph. Wheels, lamps, grille, door mirrors and handles mirror about object origins parked on the symmetry plane; the grille is authored as a half and welded on it." />
   <meta name="twitter:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/car-mirror-symmetry-hero.webp" />
-  <meta name="twitter:image:alt" content="A red low-poly hatchback with white headlights, modelled as one mirrored half." />
+  <meta name="twitter:image:alt" content="A red stylized hatchback in front three-quarter view with tinted glass, black pillars, spoked wheels, and matched headlamps and door mirrors either side of one centered grille." />
   <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>car-mirror-symmetry</h1>
-    <p>A generic hatchback lofted as one half (14 stations, 9-point rings) and completed by the Mirror modifier, evaluated through the depsgraph. Wheels and lamps mirror about object origins parked on the symmetry plane.</p>
+    <p>A stylized hatchback lofted as one half (52 stations, 13-point rings) and completed by the Mirror modifier, evaluated through the depsgraph. Wheels, lamps, grille, door mirrors and handles mirror about object origins parked on the symmetry plane; the grille is authored as a half and welded on it.</p>
   </header>
   <main id="main">
-    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: A red low-poly hatchback with white headlights, modelled as one mirrored half.">
-      <img src="../assets/car-mirror-symmetry-hero.webp" alt="A red low-poly hatchback with white headlights, modelled as one mirrored half." width="1280" height="720" />
+    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: A red stylized hatchback in front three-quarter view with tinted glass, black pillars, spoked wheels, and matched headlamps and door mirrors either side of one centered grille.">
+      <img src="../assets/car-mirror-symmetry-hero.webp" alt="A red stylized hatchback in front three-quarter view with tinted glass, black pillars, spoked wheels, and matched headlamps and door mirrors either side of one centered grille." 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> Mirror is a modifier, not applied data: the original keeps the authored half while the evaluated mesh is the welded, watertight, exactly symmetric whole.</div>
@@ -278,12 +278,13 @@ <h1>car-mirror-symmetry</h1>
       <button class="copy-btn" id="copyRun" type="button">Copy</button>
     </div>
     <section class="detail-section md">
-<p>A runnable example that builds a generic hatchback as <strong>one half</strong> — a loft of 14 stations, each a 9-point half-ring from the bottom centerline out to the roof centerline — and completes it with a <strong>Mirror modifier</strong>, evaluated through the depsgraph, following <a href="https://github.com/TMHSDigital/Blender-Developer-Tools/tree/main/skills/depsgraph-and-evaluated-data/SKILL.md"><code>depsgraph-and-evaluated-data</code></a>. Wheels and lamps are separate objects mirrored the idiomatic way: the object origin sits <strong>on</strong> the symmetry plane and the mesh data is offset — mirror mirrors about the object&#x27;s own origin, so you offset the data, never the object.</p>
+<p>A runnable example that builds a stylized hatchback as <strong>one half</strong> — a loft of 52 stations, each a 13-point half-ring from the bottom centerline out to the roof centerline — and completes it with a <strong>Mirror modifier</strong>, evaluated through the depsgraph, following <a href="https://github.com/TMHSDigital/Blender-Developer-Tools/tree/main/skills/depsgraph-and-evaluated-data/SKILL.md"><code>depsgraph-and-evaluated-data</code></a>. Wheels, headlamps, taillamps, grille, door mirrors and door handles are separate objects mirrored the idiomatic way: the object origin sits <strong>on</strong> the symmetry plane and the mesh data is offset — mirror mirrors about the object&#x27;s own origin, so you offset the data, never the object. The grille is the one part authored <em>across</em> the plane: a half profile whose end points lie exactly on <code>x = 0</code>, welded into one grille by the merge.</p>
 <p><strong>What it witnesses:</strong> the original datablock keeps only the authored half while the depsgraph carries the mirrored whole, and both directions are closed forms:</p>
-<ul><li><strong>Original holds the half.</strong> Body datablock is exactly 126 verts / 231 edges / 106 faces (14 × 9, loft closed forms), with exactly 28 centerline verts (probe: modifier applied into data → exit 3, datablock reads <code>(224, 434, 212)</code>).</li><li><strong>Evaluated is the welded whole.</strong> Exactly <code>2n − c = 224</code> verts (probe: <code>use_mirror_merge = False</code> → exit 5, <strong>252</strong> verts — the doubled seam; probe: one centerline vert pulled off the plane → exit 4, <strong>27 ≠ 28</strong> welded; probe: mirror axis off → exit 5, <strong>126</strong> — the half-car). The evaluated shell is watertight (every edge borders 2 faces) with Euler characteristic <strong>2</strong> — the two halves weld into a topological sphere.</li><li><strong>Exact ±X partners.</strong> Every evaluated vertex has a partner at negated X: measured deviation <strong>0.000e+00</strong> (mirror copies exactly; tol 2e-5 guards float32), evaluated bbox symmetric (<code>min.x == −max.x</code>).</li><li><strong>Mirrored parts.</strong> Wheels (96/81 half → 192/162 evaluated) and lamps (8/6 → 16/12) each double across the plane with partner deviation 0.0 — and each object origin reads <code>x == 0</code>.</li></ul>
+<ul><li><strong>Original holds the half.</strong> Body datablock is exactly 676 verts / 1289 edges / 614 faces (52 × 13, loft closed forms), with exactly 104 centerline verts (probe: modifier applied into data → exit 3, datablock reads <code>(1248, 2474, 1228)</code>).</li><li><strong>Evaluated is the welded whole.</strong> Exactly <code>2n − c = 1248</code> verts (probe: <code>use_mirror_merge = False</code> → exit 5, <strong>1352</strong> verts — the doubled seam; probe: one centerline vert pulled off the plane → exit 4, <strong>103 ≠ 104</strong> welded; probe: mirror axis off → exit 5, <strong>676</strong> — the half-car). The evaluated shell is watertight (every edge borders 2 faces) with Euler characteristic <strong>2</strong> — the two halves weld into a topological sphere.</li><li><strong>Exact ±X partners.</strong> Every evaluated vertex has a partner at negated X: measured deviation <strong>0.000e+00</strong> (mirror copies exactly; tol 2e-5 guards float32), evaluated bbox symmetric (<code>min.x == −max.x</code>).</li><li><strong>Mirrored parts.</strong> Offset parts double exactly: wheels 390/361 → 780/722, headlamp 64/50 → 128/100, taillamp and each handle 48/34 → 96/68, door mirror 80/66 → 160/132, partner deviation 0.0, every origin <code>x == 0</code> (probe: headlamp origin at <code>x = 0.01</code> → exit 12; probe: front wheel&#x27;s mirror axis off → exit 14, <code>(390, 361)</code>). The split grille authors 36 verts with 8 on the plane and must evaluate to <code>2n − 8 = 64</code> with exactly 8 on-plane verts (probe: grille merge off → exit 14, <strong>72</strong> verts / 16 on the plane — two grilles; probe: one grille end point moved to <code>x = 0.004</code>, beyond the merge threshold → exit 13, 7 ≠ 8 on the plane).</li></ul>
 <p><strong>Why the checks target the modifier, not the base:</strong> mutating a non-plane base vertex cannot break the ±X pairing — the evaluated set is always <code>half ∪ mirror(half)</code>, symmetric by construction. Realistic failures live in the modifier (merge off, axis off, modifier applied into data, origin off the plane), which is what the probes break.</p>
-<p><strong>Version witness:</strong> check output is byte-identical on Blender 4.5.11 LTS and 5.1.2. Mirror, <code>evaluated_get</code> / <code>to_mesh</code> / <code>to_mesh_clear</code> (no argument — passing the mesh raises TypeError on both), and <code>TRACK_TO</code> constraint behavior are stable across the pair; only the EEVEE engine id is version-gated.</p>
-<p>The render is the proof: hide the mirror and the still is literally half a car — halved windshield and hood at the centerline, one headlamp. Render notes: the loft is faceted by design (flat shading, no bevel modifier — the modifier stack is Mirror only, so counts stay closed-form); the window band is glass by construction class (steepest roof-rise slope is the windshield, steepest drop the rear window, ring segment 5 the side windows), and the glass is dielectric — metallic glass mirrors the key light and renders the windshield as a hot salmon slab. The camera stands on the key light&#x27;s side of the car: from the other side it saw only the flank the key cannot reach, and the whole visible side rendered near-black. The car is mirror-symmetric, so the composition is the same either way. The bright streak along the cowl below the windshield is the key&#x27;s highlight in a crease that faces it.</p>
+<p><strong>Version witness:</strong> check output is byte-identical on Blender 4.5.11 LTS, 5.1.2 and 5.2.1 LTS. Mirror, <code>evaluated_get</code> / <code>to_mesh</code> / <code>to_mesh_clear</code> (no argument — passing the mesh raises TypeError on both), <code>BVHTree</code>, and <code>TRACK_TO</code> constraint behavior are stable across them; only the EEVEE engine id is version-gated.</p>
+<p>The render is the proof: hide the mirror and the still is literally half a car — one headlamp, one door mirror, half a grille, a hood cut open at the centerline. The camera stands on the key light&#x27;s side, high enough to look down the hood centerline so both halves read at once. The weld itself is not a pixel witness — the hood and roof are nearly flat across the plane, so an unwelded seam renders within 12/255 of the welded one; the <code>2n − c</code> count is what catches it.</p>
+<p>Render notes: the loft is smooth-shaded with sharp edges set on the authored half by dihedral angle (35°) and material border — no bevel or weighted-normal modifier, so the stack stays Mirror only and every count stays closed-form. Boundary edges on the plane take the angle to their own mirror image, <code>acos(1 − 2nₓ²)</code>, so the centerline shades smooth. The previous faceted loft had a thin pink-white streak on the hood by the windshield: not a seam (it sat at <code>|x|</code> 0.11–0.38, on the mirrored half, and all weld checks passed) but a sliver facet — the loft&#x27;s greenhouse points collapsing onto the hood — flat-shaded and facing the key almost head on (<code>n · −key = 0.967</code>). The redesigned ring lerps a hood layout into a cabin layout, so no such sliver exists. Panel classes are by construction position: underbody, rocker and arch cladding are trim; side glass is the sill-to-glass-top segment under the roof, broken by a trim B-pillar; the drip rail becomes the A-pillar; windshield and hatch glass are the roof bands where the cabin factor ramps. The glass is a dark dielectric whose base colour ramps toward steel blue at grazing angles (Layer Weight → Color Ramp) — on a near-black stage there is little to reflect, and flat dark glass read as dull paint. Lamps, grille, mirrors and handles are closed superellipse pods seated on the skin by a <code>BVHTree</code> ray cast, with a chrome bezel and an inset lens rather than flat boxes.</p>
 <h2>Run</h2>
 <pre><code># Cheap correctness check (no render) — the CI check:
 blender --background --python car_mirror_symmetry.py --
@@ -296,7 +297,7 @@ <h2>Run</h2>
 blender --background --python car_mirror_symmetry.py -- --output car.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.</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>Body datablock is not the authored half</td></tr><tr><td>4</td><td>Authored centerline vert count ≠ 28</td></tr><tr><td>5</td><td>Evaluated verts ≠ <code>2n − c</code> (<code>--no-mirror</code> lands here)</td></tr><tr><td>6</td><td>Evaluated on-plane verts ≠ centerline; also <code>--output</code> produced no file</td></tr><tr><td>7</td><td>Evaluated Euler characteristic ≠ 2</td></tr><tr><td>8</td><td>Non-manifold edges in the evaluated shell</td></tr><tr><td>9</td><td>Evaluated verts lack a mirrored partner</td></tr><tr><td>10</td><td>Mirror partner deviation above tolerance</td></tr><tr><td>11</td><td>Evaluated bbox not symmetric about X</td></tr><tr><td>12</td><td>Mirrored-part origin off the plane</td></tr><tr><td>13</td><td>Mirrored-part datablock is not the authored half</td></tr><tr><td>14</td><td>Mirrored-part evaluated counts did not double</td></tr><tr><td>15</td><td>Mirrored-part partner check failed</td></tr><tr><td>16</td><td>Mirrored-part evaluated mesh stayed on one side</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>Body datablock is not the authored half</td></tr><tr><td>4</td><td>Authored centerline vert count ≠ 28</td></tr><tr><td>5</td><td>Evaluated verts ≠ <code>2n − c</code> (<code>--no-mirror</code> lands here)</td></tr><tr><td>6</td><td>Evaluated on-plane verts ≠ centerline; also <code>--output</code> produced no file</td></tr><tr><td>7</td><td>Evaluated Euler characteristic ≠ 2</td></tr><tr><td>8</td><td>Non-manifold edges in the evaluated shell</td></tr><tr><td>9</td><td>Evaluated verts lack a mirrored partner</td></tr><tr><td>10</td><td>Mirror partner deviation above tolerance</td></tr><tr><td>11</td><td>Evaluated bbox not symmetric about X</td></tr><tr><td>12</td><td>Mirrored-part origin off the plane</td></tr><tr><td>13</td><td>Mirrored-part datablock is not the authored half (verts, faces, on-plane verts)</td></tr><tr><td>14</td><td>Mirrored-part evaluated counts ≠ <code>2n − weld</code> / <code>2f</code>, or on-plane verts ≠ weld</td></tr><tr><td>15</td><td>Mirrored-part partner check failed</td></tr><tr><td>16</td><td>Mirrored-part evaluated mesh stayed on one side</td></tr><tr><td>17</td><td>Gallery framing violation (<code>--output</code> path only; <code>gallery_framing</code> returns 10, remapped)</td></tr><tr><td>18</td><td>Asset-quality floor violation (<code>--output</code> path only; <code>gallery_asset_quality</code> returns 11, remapped)</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>--no-mirror</code>.</p>
     </section>
     <section class="detail-section src">
@@ -305,7 +306,7 @@ <h2>Source</h2>
         <code>examples/car-mirror-symmetry/car_mirror_symmetry.py</code>
         <a href="https://github.com/TMHSDigital/Blender-Developer-Tools/tree/main/examples/car-mirror-symmetry/car_mirror_symmetry.py">View on GitHub &rarr;</a>
       </div>
-      <pre><span class="s">&quot;&quot;&quot;A generic hatchback built as one half and completed by the Mirror modifier
+      <pre><span class="s">&quot;&quot;&quot;A stylized hatchback built as one half and completed by the Mirror modifier
 — a runnable example.
 
 Witnesses the Mirror + depsgraph contract from depsgraph-and-evaluated-data:
@@ -314,8 +315,9 @@ <h2>Source</h2>
 2n - c (c = welded centerline verts), every evaluated vertex has an exact
 partner at negated X, the merge threshold actually welds (no doubled
 centerline), the evaluated shell is watertight with Euler characteristic 2,
-and the wheels mirror about their object origins sitting ON the symmetry
-plane. Failure is dramatically visible: a car with one side missing.
+and every separate part (wheels, lamps, grille, mirrors, handles) mirrors about
+an object origin sitting ON the symmetry plane. Failure is dramatically
+visible: a car with one side missing.
 
 ``--no-mirror`` turns off the Mirror X axis on every mirrored object and
 still runs the evaluated-count check, so the half-car fails ``2n − c``.
@@ -329,64 +331,142 @@ <h2>Source</h2>
     blender --background --python car_mirror_symmetry.py -- --output c.png  # + render
 &quot;&quot;&quot;</span>
 <span class="k">import</span> bpy, bmesh, sys, os, math, argparse
+<span class="k">from</span> mathutils <span class="k">import</span> Vector
+<span class="k">from</span> mathutils.bvhtree <span class="k">import</span> BVHTree
 
 <span class="c"># --- closed-form construction parameters -----------------------------------</span>
-<span class="c"># 14 loft stations along Y (front at -Y), each a 9-point half-ring from the</span>
-<span class="c"># bottom centerline out and up to the roof centerline. Fields:</span>
-<span class="c"># (y, w_side, z_floor, z_sill, z_side, w_glass, z_glass_base, w_roof, z_roof)</span>
-STATIONS = [
-    (-<span class="n">1.95</span>, <span class="n">0.74</span>, <span class="n">0.34</span>, <span class="n">0.36</span>, <span class="n">0.52</span>, <span class="n">0.05</span>, <span class="n">0.62</span>, <span class="n">0.04</span>, <span class="n">0.64</span>),  <span class="c"># nose tip</span>
-    (-<span class="n">1.80</span>, <span class="n">0.83</span>, <span class="n">0.30</span>, <span class="n">0.32</span>, <span class="n">0.55</span>, <span class="n">0.08</span>, <span class="n">0.70</span>, <span class="n">0.07</span>, <span class="n">0.73</span>),  <span class="c"># front bumper</span>
-    (-<span class="n">1.65</span>, <span class="n">0.86</span>, <span class="n">0.28</span>, <span class="n">0.28</span>, <span class="n">0.54</span>, <span class="n">0.10</span>, <span class="n">0.72</span>, <span class="n">0.09</span>, <span class="n">0.74</span>),
-    (-<span class="n">1.30</span>, <span class="n">0.87</span>, <span class="n">0.28</span>, <span class="n">0.62</span>, <span class="n">0.66</span>, <span class="n">0.11</span>, <span class="n">0.74</span>, <span class="n">0.10</span>, <span class="n">0.76</span>),  <span class="c"># front arch peak</span>
-    (-<span class="n">0.95</span>, <span class="n">0.86</span>, <span class="n">0.28</span>, <span class="n">0.28</span>, <span class="n">0.54</span>, <span class="n">0.12</span>, <span class="n">0.78</span>, <span class="n">0.11</span>, <span class="n">0.80</span>),
-    (-<span class="n">0.60</span>, <span class="n">0.85</span>, <span class="n">0.28</span>, <span class="n">0.28</span>, <span class="n">0.55</span>, <span class="n">0.38</span>, <span class="n">0.90</span>, <span class="n">0.34</span>, <span class="n">0.95</span>),  <span class="c"># hood -&gt; cowl</span>
-    (-<span class="n">0.30</span>, <span class="n">0.84</span>, <span class="n">0.28</span>, <span class="n">0.28</span>, <span class="n">0.56</span>, <span class="n">0.54</span>, <span class="n">1.02</span>, <span class="n">0.50</span>, <span class="n">1.30</span>),  <span class="c"># windshield</span>
-    ( <span class="n">0.20</span>, <span class="n">0.83</span>, <span class="n">0.28</span>, <span class="n">0.28</span>, <span class="n">0.57</span>, <span class="n">0.60</span>, <span class="n">1.05</span>, <span class="n">0.56</span>, <span class="n">1.45</span>),  <span class="c"># roof front</span>
-    ( <span class="n">0.70</span>, <span class="n">0.83</span>, <span class="n">0.28</span>, <span class="n">0.28</span>, <span class="n">0.57</span>, <span class="n">0.60</span>, <span class="n">1.05</span>, <span class="n">0.55</span>, <span class="n">1.44</span>),  <span class="c"># roof rear</span>
-    ( <span class="n">0.95</span>, <span class="n">0.84</span>, <span class="n">0.28</span>, <span class="n">0.28</span>, <span class="n">0.56</span>, <span class="n">0.58</span>, <span class="n">1.04</span>, <span class="n">0.52</span>, <span class="n">1.38</span>),
-    ( <span class="n">1.30</span>, <span class="n">0.85</span>, <span class="n">0.28</span>, <span class="n">0.62</span>, <span class="n">0.68</span>, <span class="n">0.50</span>, <span class="n">1.00</span>, <span class="n">0.44</span>, <span class="n">1.24</span>),  <span class="c"># rear arch peak</span>
-    ( <span class="n">1.65</span>, <span class="n">0.84</span>, <span class="n">0.28</span>, <span class="n">0.28</span>, <span class="n">0.55</span>, <span class="n">0.34</span>, <span class="n">0.95</span>, <span class="n">0.28</span>, <span class="n">1.10</span>),  <span class="c"># hatch</span>
-    ( <span class="n">1.90</span>, <span class="n">0.80</span>, <span class="n">0.30</span>, <span class="n">0.32</span>, <span class="n">0.53</span>, <span class="n">0.12</span>, <span class="n">0.86</span>, <span class="n">0.11</span>, <span class="n">0.92</span>),  <span class="c"># tail</span>
-    ( <span class="n">2.00</span>, <span class="n">0.72</span>, <span class="n">0.34</span>, <span class="n">0.36</span>, <span class="n">0.50</span>, <span class="n">0.05</span>, <span class="n">0.78</span>, <span class="n">0.04</span>, <span class="n">0.78</span>),  <span class="c"># rear bumper</span>
-]
-RING = <span class="n">9</span>                       <span class="c"># points per half-ring, p0 and p8 on the centerline</span>
-WHEEL_SEG = <span class="n">16</span>
-WHEEL_RINGS = [                <span class="c"># (x, radius) profile: bead, tread, sidewall, rim, cap</span>
-    (<span class="n">0.63</span>, <span class="n">0.30</span>), (<span class="n">0.67</span>, <span class="n">0.33</span>), (<span class="n">0.83</span>, <span class="n">0.33</span>), (<span class="n">0.87</span>, <span class="n">0.30</span>), (<span class="n">0.89</span>, <span class="n">0.19</span>), (<span class="n">0.90</span>, <span class="n">0.15</span>),
-]
-WHEEL_Y = (-<span class="n">1.3</span>, <span class="n">1.3</span>)          <span class="c"># front / rear axle positions</span>
-WHEEL_Z = <span class="n">0.33</span>                 <span class="c"># axle height == tire radius: wheels rest on z=0</span>
-
-N_BODY = len(STATIONS) * RING                    <span class="c"># 126</span>
-F_BODY = (len(STATIONS) - <span class="n">1</span>) * (RING - <span class="n">1</span>) + <span class="n">2</span>    <span class="c"># 104 quads + 2 caps</span>
-E_BODY = (len(STATIONS) * (RING - <span class="n">1</span>)             <span class="c"># ring edges</span>
-          + (len(STATIONS) - <span class="n">1</span>) * RING           <span class="c"># longitudinal edges</span>
+<span class="c"># The half body is a loft: one 13-point half-ring per station along Y (front</span>
+<span class="c"># at -Y), from the bottom centerline (p0) out and up to the roof centerline</span>
+<span class="c"># (p12). Station Ys are placed, not sampled: every panel edge the design</span>
+<span class="c"># needs (arch openings, cowl, B-pillar, roof end, hatch base) is a station.</span>
+RING = <span class="n">13</span>
+AXLES = (-<span class="n">1.22</span>, <span class="n">1.22</span>)          <span class="c"># front / rear axle Y</span>
+TIRE_R = <span class="n">0.33</span>                  <span class="c"># axle height == tire radius: wheels rest on z=0</span>
+ARCH_R = <span class="n">0.40</span>                  <span class="c"># wheel-arch opening radius about the axle</span>
+Y_NOSE, Y_TAIL = -<span class="n">1.95</span>, <span class="n">1.90</span>
+Y_COWL, Y_ROOF0 = -<span class="n">0.60</span>, <span class="n">0.02</span>  <span class="c"># windshield base / top</span>
+Y_ROOF1, Y_HATCH = <span class="n">1.30</span>, <span class="n">1.78</span>  <span class="c"># roof end / hatch-glass base</span>
+Y_BPILLAR = (<span class="n">0.18</span>, <span class="n">0.30</span>)
+Y_CPILLAR = <span class="n">1.05</span>
+
+
+<span class="k">def</span> _stations():
+    ys = {Y_NOSE, -<span class="n">1.93</span>, -<span class="n">1.89</span>, -<span class="n">1.83</span>, -<span class="n">1.71</span>,               <span class="c"># rounded nose</span>
+          -<span class="n">0.70</span>, Y_COWL, -<span class="n">0.44</span>, -<span class="n">0.28</span>, -<span class="n">0.13</span>, Y_ROOF0,       <span class="c"># windshield</span>
+          Y_BPILLAR[<span class="n">0</span>], Y_BPILLAR[<span class="n">1</span>], <span class="n">0.50</span>, <span class="n">0.70</span>, Y_CPILLAR,
+          Y_ROOF1, <span class="n">1.74</span>, Y_HATCH, <span class="n">1.83</span>, <span class="n">1.87</span>, Y_TAIL}        <span class="c"># hatch + tail</span>
+    <span class="k">for</span> a <span class="k">in</span> AXLES:                                          <span class="c"># arch openings</span>
+        ys.add(round(a - ARCH_R - <span class="n">0.03</span>, <span class="n">4</span>))
+        ys.add(round(a + ARCH_R + <span class="n">0.03</span>, <span class="n">4</span>))
+        <span class="k">for</span> s <span class="k">in</span> range(<span class="n">13</span>):
+            ys.add(round(a - ARCH_R * math.cos(math.pi * s / <span class="n">12</span>), <span class="n">4</span>))
+    <span class="k">return</span> sorted(ys)
+
+
+STATION_Y = _stations()
+N_ST = len(STATION_Y)                            <span class="c"># 52</span>
+N_BODY = N_ST * RING                             <span class="c"># 676</span>
+F_BODY = (N_ST - <span class="n">1</span>) * (RING - <span class="n">1</span>) + <span class="n">2</span>             <span class="c"># 612 quads + 2 caps</span>
+E_BODY = (N_ST * (RING - <span class="n">1</span>)                      <span class="c"># ring edges</span>
+          + (N_ST - <span class="n">1</span>) * RING                    <span class="c"># longitudinal edges</span>
           + <span class="n">2</span>)                                   <span class="c"># cap closing edges</span>
-CENTERLINE = len(STATIONS) * <span class="n">2</span>                   <span class="c"># p0 + p8 per station: 28</span>
-N_WHEEL = len(WHEEL_RINGS) * WHEEL_SEG           <span class="c"># 96</span>
+CENTERLINE = N_ST * <span class="n">2</span>                            <span class="c"># p0 + p12 per station: 104</span>
+
+WHEEL_SEG = <span class="n">30</span>                 <span class="c"># 5 spokes x 6 segments</span>
+WHEEL_RINGS = [                <span class="c"># (x, radius): tire bead -&gt; tread -&gt; rim -&gt; hub cap</span>
+    (<span class="n">0.600</span>, <span class="n">0.200</span>), (<span class="n">0.605</span>, <span class="n">0.285</span>), (<span class="n">0.625</span>, <span class="n">0.322</span>), (<span class="n">0.660</span>, <span class="n">0.330</span>),
+    (<span class="n">0.840</span>, <span class="n">0.330</span>), (<span class="n">0.865</span>, <span class="n">0.322</span>), (<span class="n">0.882</span>, <span class="n">0.290</span>), (<span class="n">0.886</span>, <span class="n">0.238</span>),
+    (<span class="n">0.880</span>, <span class="n">0.224</span>), (<span class="n">0.868</span>, <span class="n">0.206</span>), (<span class="n">0.868</span>, <span class="n">0.086</span>), (<span class="n">0.874</span>, <span class="n">0.064</span>),
+    (<span class="n">0.882</span>, <span class="n">0.040</span>),
+]
+DISH_RINGS = (<span class="n">9</span>, <span class="n">10</span>)           <span class="c"># rings whose gap verts recess to form spokes</span>
+DISH_GAP_X = <span class="n">0.820</span>
+N_WHEEL = len(WHEEL_RINGS) * WHEEL_SEG           <span class="c"># 390</span>
 F_WHEEL = (len(WHEEL_RINGS) - <span class="n">1</span>) * WHEEL_SEG + <span class="n">1</span> <span class="c"># strips + hubcap ngon</span>
 
+POD_P = <span class="n">16</span>                     <span class="c"># profile points per pod ring (lamps, grille, mirror)</span>
+
 MERGE_THRESHOLD = <span class="n">1.0e-3</span>
 TOL_SYMM = <span class="n">2.0e-5</span>    <span class="c"># evaluated partner deviation (float32 storage; mirror copies exact)</span>
 TOL_BBOX = <span class="n">1.0e-5</span>    <span class="c"># |min.x + max.x| on the evaluated body</span>
 TOL_PLANE = <span class="n">1.0e-6</span>   <span class="c"># |x| this small counts as on the symmetry plane</span>
 
+MATERIALS = (<span class="s">&quot;Paint&quot;</span>, <span class="s">&quot;Glass&quot;</span>, <span class="s">&quot;Trim&quot;</span>, <span class="s">&quot;Chrome&quot;</span>, <span class="s">&quot;Tire&quot;</span>, <span class="s">&quot;Rim&quot;</span>,
+             <span class="s">&quot;Headlamp&quot;</span>, <span class="s">&quot;Taillamp&quot;</span>)
+
+
+<span class="c"># --- profile functions (all closed-form in y) ------------------------------</span>
+<span class="k">def</span> _clamp(t):
+    <span class="k">return</span> <span class="n">0.0</span> <span class="k">if</span> t &lt; <span class="n">0.0</span> <span class="k">else</span> <span class="n">1.0</span> <span class="k">if</span> t &gt; <span class="n">1.0</span> <span class="k">else</span> t
+
+
+<span class="k">def</span> _ramp(y, y0, y1):
+    <span class="k">return</span> _clamp((y - y0) / (y1 - y0))
+
+
+<span class="k">def</span> _interp(y, pts):
+    <span class="k">if</span> y &lt;= pts[<span class="n">0</span>][<span class="n">0</span>]:
+        <span class="k">return</span> pts[<span class="n">0</span>][<span class="n">1</span>]
+    <span class="k">for</span> (y0, v0), (y1, v1) <span class="k">in</span> zip(pts, pts[<span class="n">1</span>:]):
+        <span class="k">if</span> y &lt;= y1:
+            t = (y - y0) / (y1 - y0)
+            t = t * t * (<span class="n">3.0</span> - <span class="n">2.0</span> * t)          <span class="c"># smoothstep between keys</span>
+            <span class="k">return</span> v0 + (v1 - v0) * t
+    <span class="k">return</span> pts[-<span class="n">1</span>][<span class="n">1</span>]
+
+
+<span class="k">def</span> _round(t):
+    <span class="s">&quot;&quot;&quot;Quarter-circle rounding: 0 at the very end, 1 once the body is full.&quot;&quot;&quot;</span>
+    t = _clamp(t)
+    <span class="k">return</span> math.sqrt(max(<span class="n">0.0</span>, <span class="n">1.0</span> - (<span class="n">1.0</span> - t) ** <span class="n">2</span>))
+
+
+<span class="k">def</span> cabin(y):
+    <span class="s">&quot;&quot;&quot;0 on hood / rear deck, 1 under the roof, linear through the glass.&quot;&quot;&quot;</span>
+    <span class="k">return</span> min(_ramp(y, Y_COWL, Y_ROOF0), <span class="n">1.0</span> - _ramp(y, Y_ROOF1, Y_HATCH))
+
+
+<span class="k">def</span> half_ring(y):
+    <span class="s">&quot;&quot;&quot;One 13-point half cross-section at y, bottom centerline -&gt; roof centerline.&quot;&quot;&quot;</span>
+    rn = min(_round((y - Y_NOSE) / <span class="n">0.24</span>), _round((Y_TAIL - y) / <span class="n">0.16</span>))
+    f = <span class="n">0.70</span> + <span class="n">0.30</span> * rn                     <span class="c"># plan-view corner rounding</span>
+    br = <span class="n">0.06</span> * (<span class="n">1.0</span> - rn)                   <span class="c"># bottom tucks up at the ends</span>
+    td = <span class="n">0.035</span> * (<span class="n">1.0</span> - rn)                  <span class="c"># top rolls down at the ends</span>
+    flare = max(math.exp(-((y - a) / <span class="n">0.42</span>) ** <span class="n">2</span>) <span class="k">for</span> a <span class="k">in</span> AXLES)
+    w = (<span class="n">0.84</span> + <span class="n">0.04</span> * flare) * f            <span class="c"># half width, flared over wheels</span>
+    zbelt = _interp(y, [(-<span class="n">1.95</span>, <span class="n">0.74</span>), (-<span class="n">1.60</span>, <span class="n">0.80</span>), (-<span class="n">1.22</span>, <span class="n">0.84</span>),
+                        (-<span class="n">0.60</span>, <span class="n">0.915</span>), (<span class="n">0.50</span>, <span class="n">0.945</span>), (<span class="n">1.30</span>, <span class="n">0.955</span>),
+                        (<span class="n">1.90</span>, <span class="n">0.935</span>)]) - td
+    ztop = (_interp(y, [(-<span class="n">1.95</span>, <span class="n">0.80</span>), (-<span class="n">1.60</span>, <span class="n">0.86</span>), (-<span class="n">1.00</span>, <span class="n">0.91</span>),
+                        (-<span class="n">0.60</span>, <span class="n">0.965</span>)]) <span class="k">if</span> y &lt; <span class="n">0.5</span> <span class="k">else</span>
+            _interp(y, [(<span class="n">1.30</span>, <span class="n">1.02</span>), (<span class="n">1.78</span>, <span class="n">1.01</span>), (<span class="n">1.90</span>, <span class="n">0.975</span>)])) - td
+    zroof = _interp(y, [(-<span class="n">0.60</span>, <span class="n">1.32</span>), (<span class="n">0.02</span>, <span class="n">1.34</span>), (<span class="n">0.60</span>, <span class="n">1.36</span>),
+                        (<span class="n">1.30</span>, <span class="n">1.33</span>)])
+    crease = zbelt - <span class="n">0.15</span>
+    zfloor = <span class="n">0.20</span> + br
+
+    d = min((abs(y - a) <span class="k">for</span> a <span class="k">in</span> AXLES))
+    <span class="k">if</span> d &lt;= ARCH_R + <span class="n">1e-9</span>:                   <span class="c"># inside a wheel-arch opening</span>
+        za = TIRE_R + math.sqrt(max(<span class="n">0.0</span>, ARCH_R ** <span class="n">2</span> - d * d))
+        lower = [(<span class="n">0.50</span>, za), (<span class="n">0.93</span> * w, za), (<span class="n">0.99</span> * w, za), (w, za + <span class="n">0.06</span>),
+                 (<span class="n">1.01</span> * w, max(crease, za + <span class="n">0.10</span>))]   <span class="c"># cladding flares out</span>
+    <span class="k">else</span>:
+        lower = [(<span class="n">0.50</span>, zfloor), (<span class="n">0.95</span> * w, <span class="n">0.24</span> + br), (<span class="n">0.975</span> * w, <span class="n">0.28</span> + br),
+                 (<span class="n">0.975</span> * w, <span class="n">0.36</span> + <span class="n">0.5</span> * br), (<span class="n">1.01</span> * w, crease)]  <span class="c"># p5: character line</span>
+
+    c = cabin(y)
+    wr = <span class="n">0.70</span> * w
+    cab = [(<span class="n">0.93</span> * w, zbelt + <span class="n">0.03</span>), (wr + <span class="n">0.05</span>, zroof - <span class="n">0.09</span>),
+           (wr, zroof - <span class="n">0.035</span>), (<span class="n">0.80</span> * wr, zroof), (<span class="n">0.42</span> * wr, zroof + <span class="n">0.018</span>),
+           (<span class="n">0.0</span>, zroof + <span class="n">0.022</span>)]
+    hood = []
+    <span class="k">for</span> fx <span class="k">in</span> (<span class="n">0.91</span>, <span class="n">0.80</span>, <span class="n">0.66</span>, <span class="n">0.50</span>, <span class="n">0.27</span>, <span class="n">0.0</span>):
+        hood.append((fx * w, ztop - (ztop - zbelt) * (fx / <span class="n">0.965</span>) ** <span class="n">2</span>))
+    upper = [(h[<span class="n">0</span>] + (k[<span class="n">0</span>] - h[<span class="n">0</span>]) * c, h[<span class="n">1</span>] + (k[<span class="n">1</span>] - h[<span class="n">1</span>]) * c)
+             <span class="k">for</span> h, k <span class="k">in</span> zip(hood, cab)]
 
-<span class="k">def</span> half_ring(st):
-    <span class="s">&quot;&quot;&quot;One 9-point half cross-section, bottom centerline -&gt; roof centerline.&quot;&quot;&quot;</span>
-    y, w, zf, zsill, zside, wg, zgb, wr, zroof = st
-    <span class="k">return</span> [
-        (<span class="n">0.0</span>, y, zf),                 <span class="c"># p0 bottom centerline</span>
-        (<span class="n">0.55</span> * w, y, zf - <span class="n">0.02</span>),     <span class="c"># p1 underbody</span>
-        (<span class="n">0.95</span> * w, y, zsill),         <span class="c"># p2 sill (rises over wheel arches)</span>
-        (w, y, zside),                <span class="c"># p3 lower door (widest)</span>
-        (<span class="n">0.99</span> * w, y, zside + <span class="n">0.10</span>),  <span class="c"># p4 shoulder</span>
-        (wg, y, zgb),                 <span class="c"># p5 greenhouse base</span>
-        (wr, y, zroof),               <span class="c"># p6 roof edge</span>
-        (<span class="n">0.55</span> * wr, y, zroof + <span class="n">0.015</span>),<span class="c"># p7 roof crown</span>
-        (<span class="n">0.0</span>, y, zroof),              <span class="c"># p8 top centerline</span>
-    ]
+    pts = [(<span class="n">0.0</span>, zfloor)] + lower + [(<span class="n">0.965</span> * w, zbelt)] + upper
+    <span class="k">return</span> [(x, y, z) <span class="k">for</span> x, z <span class="k">in</span> pts]
 
 
 <span class="k">def</span> _newell(pts):
@@ -400,24 +480,105 @@ <h2>Source</h2>
     <span class="k">return</span> (nx / n, ny / n, nz / n)
 
 
+<span class="k">def</span> _link_mirrored(name, me):
+    <span class="s">&quot;&quot;&quot;Object at the world origin (ON the plane) + Mirror X with merge.&quot;&quot;&quot;</span>
+    ob = bpy.data.objects.new(name, me)
+    bpy.context.collection.objects.link(ob)
+    m = ob.modifiers.new(<span class="s">&quot;MirrorHalf&quot;</span>, <span class="s">&#x27;MIRROR&#x27;</span>)
+    m.use_axis[<span class="n">0</span>] = <span class="k">True</span>
+    m.use_mirror_merge = <span class="k">True</span>
+    m.merge_threshold = MERGE_THRESHOLD
+    <span class="k">return</span> ob
+
+
+<span class="k">def</span> pod(name, center, normal, half_w, half_h, rings, band_mats, cap_mat,
+        up=(<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">1.0</span>), expo=<span class="n">4.0</span>, split=<span class="k">False</span>):
+    <span class="s">&quot;&quot;&quot;Superellipse pod: len(rings) rings, capped at both ends.
+    rings = [(scale, depth along normal)], back to front.
+
+    Offset pod (split=False): POD_P points per closed ring, entirely off the
+    plane. Closed form n = R * POD_P, f = (R - 1) * POD_P + 2, welds 0.
+    Split pod (split=True, center ON the plane, normal in the plane): only
+    the +X half profile, POD_P/2 + 1 points from bottom to top with both
+    ends exactly at x = 0 — the Mirror weld completes it into one part.
+    Closed form n = R * (POD_P/2 + 1), f = (R - 1) * POD_P/2 + 2, welds 2R.
+    Either way the object origin stays on the plane.
+    Returns (object, n_half, f_half, welded).&quot;&quot;&quot;</span>
+    n = Vector(normal).normalized()
+    u = Vector(up).cross(n).normalized()
+    v = n.cross(u).normalized()
+    ctr = Vector(center)
+    npts = POD_P // <span class="n">2</span> + <span class="n">1</span> <span class="k">if</span> split <span class="k">else</span> POD_P
+    nfac = POD_P // <span class="n">2</span> <span class="k">if</span> split <span class="k">else</span> POD_P
+    me = bpy.data.meshes.new(name + <span class="s">&quot;Half&quot;</span>)
+    bm = bmesh.new()
+    <span class="k">try</span>:
+        rv = []
+        <span class="k">for</span> scale, depth <span class="k">in</span> rings:
+            ring = []
+            <span class="k">for</span> s <span class="k">in</span> range(npts):
+                a = (math.pi * (s / (npts - <span class="n">1</span>) - <span class="n">0.5</span>) <span class="k">if</span> split
+                     <span class="k">else</span> <span class="n">2.0</span> * math.pi * s / POD_P)
+                ca, sa = math.cos(a), math.sin(a)
+                <span class="k">if</span> split <span class="k">and</span> s <span class="k">in</span> (<span class="n">0</span>, npts - <span class="n">1</span>):
+                    ca = <span class="n">0.0</span>                     <span class="c"># exactly on the plane</span>
+                px = math.copysign(abs(ca) ** (<span class="n">2.0</span> / expo), ca) * half_w * scale
+                py = math.copysign(abs(sa) ** (<span class="n">2.0</span> / expo), sa) * half_h * scale
+                ring.append(bm.verts.new(ctr + u * px + v * py + n * depth))
+            rv.append(ring)
+        bands = []
+        <span class="k">for</span> b <span class="k">in</span> range(len(rings) - <span class="n">1</span>):
+            <span class="k">for</span> s <span class="k">in</span> range(nfac):
+                f = bm.faces.new((rv[b][s], rv[b][(s + <span class="n">1</span>) % npts],
+                                  rv[b + <span class="n">1</span>][(s + <span class="n">1</span>) % npts], rv[b + <span class="n">1</span>][s]))
+                f.material_index = band_mats[b]
+                bands.append(f)
+        back = bm.faces.new(rv[<span class="n">0</span>])
+        back.material_index = band_mats[<span class="n">0</span>]
+        front = bm.faces.new(rv[-<span class="n">1</span>])
+        front.material_index = cap_mat
+        <span class="k">if</span> <span class="k">not</span> split:
+            bmesh.ops.recalc_face_normals(bm, faces=bm.faces)  <span class="c"># closed: outward</span>
+        <span class="k">else</span>:  <span class="c"># open along the plane: orient explicitly</span>
+            side = bands[nfac // <span class="n">2</span>]          <span class="c"># outboard wall of the first band</span>
+            <span class="k">if</span> side.normal.dot(u) &lt; <span class="n">0</span>:
+                <span class="k">for</span> f <span class="k">in</span> bands:
+                    f.normal_flip()
+            <span class="k">if</span> front.normal.dot(n) &lt; <span class="n">0</span>:
+                front.normal_flip()
+            <span class="k">if</span> back.normal.dot(n) &gt; <span class="n">0</span>:
+                back.normal_flip()
+        bm.to_mesh(me)
+    <span class="k">finally</span>:
+        bm.free()
+    <span class="k">for</span> m <span class="k">in</span> MATERIALS:
+        me.materials.append(bpy.data.materials[m])
+    ob = _link_mirrored(name, me)
+    R = len(rings)
+    <span class="k">return</span> ob, R * npts, (R - <span class="n">1</span>) * nfac + <span class="n">2</span>, (<span class="n">2</span> * R <span class="k">if</span> split <span class="k">else</span> <span class="n">0</span>)
+
+
 <span class="k">def</span> build_car():
     bpy.ops.wm.read_factory_settings(use_empty=<span class="k">True</span>)
+    <span class="k">for</span> m <span class="k">in</span> MATERIALS:  <span class="c"># exist in both modes (slot layout is part of the scene)</span>
+        bpy.data.materials.new(m)
 
     <span class="c"># -- half body loft ------------------------------------------------------</span>
-    rings = [half_ring(st) <span class="k">for</span> st <span class="k">in</span> STATIONS]
+    rings = [half_ring(y) <span class="k">for</span> y <span class="k">in</span> STATION_Y]
     me = bpy.data.meshes.new(<span class="s">&quot;CarBodyHalf&quot;</span>)
     bm = bmesh.new()
     <span class="k">try</span>:
         bv = [[bm.verts.new(co) <span class="k">for</span> co <span class="k">in</span> ring] <span class="k">for</span> ring <span class="k">in</span> rings]
         faces = []
-        <span class="k">for</span> i <span class="k">in</span> range(len(STATIONS) - <span class="n">1</span>):
+        <span class="k">for</span> i <span class="k">in</span> range(N_ST - <span class="n">1</span>):
             <span class="k">for</span> k <span class="k">in</span> range(RING - <span class="n">1</span>):
                 faces.append(bm.faces.new(
                     (bv[i][k], bv[i][k + <span class="n">1</span>], bv[i + <span class="n">1</span>][k + <span class="n">1</span>], bv[i + <span class="n">1</span>][k])))
         caps = [bm.faces.new(bv[<span class="n">0</span>]), bm.faces.new(bv[-<span class="n">1</span>])]
-        <span class="c"># winding: the probe side quad must face +X; flip everything if the</span>
-        <span class="c"># loft convention came out inward (mirror does not fix winding)</span>
-        probe = [v.co <span class="k">for</span> v <span class="k">in</span> (bv[<span class="n">8</span>][<span class="n">3</span>], bv[<span class="n">8</span>][<span class="n">4</span>], bv[<span class="n">9</span>][<span class="n">4</span>], bv[<span class="n">9</span>][<span class="n">3</span>])]
+        <span class="c"># winding: a door quad must face +X; flip everything if the loft</span>
+        <span class="c"># convention came out inward (mirror does not fix winding)</span>
+        mid = N_ST // <span class="n">2</span>
+        probe = [v.co <span class="k">for</span> v <span class="k">in</span> (bv[mid][<span class="n">4</span>], bv[mid][<span class="n">5</span>], bv[mid + <span class="n">1</span>][<span class="n">5</span>], bv[mid + <span class="n">1</span>][<span class="n">4</span>])]
         <span class="k">if</span> _newell(probe)[<span class="n">0</span>] &lt; <span class="n">0</span>:
             <span class="k">for</span> f <span class="k">in</span> faces + caps:
                 f.normal_flip()
@@ -427,6 +588,8 @@ <h2>Source</h2>
         <span class="k">if</span> _newell([v.co <span class="k">for</span> v <span class="k">in</span> bv[-<span class="n">1</span>]])[<span class="n">1</span>] &lt; <span class="n">0</span>:
             caps[<span class="n">1</span>].normal_flip()
         bm.to_mesh(me)
+        bm.faces.ensure_lookup_table()
+        bvh = BVHTree.FromBMesh(bm)  <span class="c"># seats the separate parts on the skin</span>
     <span class="k">finally</span>:
         bm.free()  <span class="c"># the ownership contract from always-free-bmesh</span>
 
@@ -437,110 +600,131 @@ <h2>Source</h2>
     mirror.use_clip = <span class="k">True</span>            <span class="c"># centerline verts cannot leave x=0</span>
     mirror.use_mirror_merge = <span class="k">True</span>    <span class="c"># weld the two halves shut</span>
     mirror.merge_threshold = MERGE_THRESHOLD
+    <span class="k">for</span> m <span class="k">in</span> MATERIALS:
+        me.materials.append(bpy.data.materials[m])
+    _assign_body_materials(body)
+
+    <span class="k">def</span> skin_y(x, z, front=<span class="k">True</span>):
+        <span class="s">&quot;&quot;&quot;Y of the body surface at (x, z), probed along the long axis.&quot;&quot;&quot;</span>
+        o = Vector((x, -<span class="n">5.0</span> <span class="k">if</span> front <span class="k">else</span> <span class="n">5.0</span>, z))
+        hit = bvh.ray_cast(o, Vector((<span class="n">0.0</span>, <span class="n">1.0</span> <span class="k">if</span> front <span class="k">else</span> -<span class="n">1.0</span>, <span class="n">0.0</span>)))
+        <span class="k">return</span> hit[<span class="n">0</span>].y
+
+    <span class="k">def</span> skin_x(y, z):
+        <span class="s">&quot;&quot;&quot;X of the +X flank at (y, z), probed inward from outside.&quot;&quot;&quot;</span>
+        <span class="k">return</span> bvh.ray_cast(Vector((<span class="n">5.0</span>, y, z)), Vector((-<span class="n">1.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>)))[<span class="n">0</span>].x
 
     <span class="c"># -- wheels: own Mirror each, object origins ON the symmetry plane -------</span>
-    wheels = []
-    <span class="k">for</span> y <span class="k">in</span> WHEEL_Y:
+    mirrored = []
+    <span class="k">for</span> y <span class="k">in</span> AXLES:
         wme = bpy.data.meshes.new(<span class="s">&quot;WheelHalf&quot;</span>)
         bm = bmesh.new()
         <span class="k">try</span>:
             wr = []
-            <span class="k">for</span> x, r <span class="k">in</span> WHEEL_RINGS:
-                wr.append([bm.verts.new(
-                    (x, r * math.cos(<span class="n">2.0</span> * math.pi * s / WHEEL_SEG),
-                     r * math.sin(<span class="n">2.0</span> * math.pi * s / WHEEL_SEG)))
-                    <span class="k">for</span> s <span class="k">in</span> range(WHEEL_SEG)])
+            <span class="k">for</span> j, (x, r) <span class="k">in</span> enumerate(WHEEL_RINGS):
+                ring = []
+                <span class="k">for</span> s <span class="k">in</span> range(WHEEL_SEG):
+                    gap = j <span class="k">in</span> DISH_RINGS <span class="k">and</span> s % <span class="n">6</span> <span class="k">in</span> (<span class="n">3</span>, <span class="n">4</span>, <span class="n">5</span>)
+                    a = <span class="n">2.0</span> * math.pi * s / WHEEL_SEG
+                    ring.append(bm.verts.new((DISH_GAP_X <span class="k">if</span> gap <span class="k">else</span> x,
+                                              r * math.cos(a), r * math.sin(a))))
+                wr.append(ring)
+            strips = []
             <span class="k">for</span> j <span class="k">in</span> range(len(WHEEL_RINGS) - <span class="n">1</span>):
                 <span class="k">for</span> s <span class="k">in</span> range(WHEEL_SEG):
-                    bm.faces.new((wr[j][s], wr[j][(s + <span class="n">1</span>) % WHEEL_SEG],
-                                  wr[j + <span class="n">1</span>][(s + <span class="n">1</span>) % WHEEL_SEG], wr[j + <span class="n">1</span>][s]))
-            bm.faces.new(wr[-<span class="n">1</span>])  <span class="c"># hubcap ngon</span>
+                    f = bm.faces.new((wr[j][s], wr[j][(s + <span class="n">1</span>) % WHEEL_SEG],
+                                      wr[j + <span class="n">1</span>][(s + <span class="n">1</span>) % WHEEL_SEG], wr[j + <span class="n">1</span>][s]))
+                    strips.append(f)
+                    <span class="k">if</span> j &lt;= <span class="n">6</span>:
+                        f.material_index = MATERIALS.index(<span class="s">&quot;Tire&quot;</span>)
+                    <span class="k">elif</span> <span class="n">8</span> &lt;= j &lt;= <span class="n">10</span> <span class="k">and</span> s % <span class="n">6</span> <span class="k">in</span> (<span class="n">3</span>, <span class="n">4</span>):
+                        f.material_index = MATERIALS.index(<span class="s">&quot;Trim&quot;</span>)   <span class="c"># spoke gaps</span>
+                    <span class="k">else</span>:
+                        f.material_index = MATERIALS.index(<span class="s">&quot;Rim&quot;</span>)
+            hub = bm.faces.new(wr[-<span class="n">1</span>])
+            hub.material_index = MATERIALS.index(<span class="s">&quot;Rim&quot;</span>)
+            <span class="c"># tread faces point away from the axle; hub cap faces +X</span>
+            t = strips[<span class="n">3</span> * WHEEL_SEG]
+            c = t.calc_center_median()
+            <span class="k">if</span> t.normal.dot(Vector((<span class="n">0.0</span>, c.y, c.z))) &lt; <span class="n">0</span>:
+                <span class="k">for</span> f <span class="k">in</span> strips:
+                    f.normal_flip()
+            <span class="k">if</span> hub.normal.x &lt; <span class="n">0</span>:
+                hub.normal_flip()
             bm.to_mesh(wme)
         <span class="k">finally</span>:
             bm.free()
-        wheel = bpy.data.objects.new(<span class="s">&quot;WheelFront&quot;</span> <span class="k">if</span> y &lt; <span class="n">0</span> <span class="k">else</span> <span class="s">&quot;WheelRear&quot;</span>, wme)
-        wheel.location = (<span class="n">0.0</span>, y, WHEEL_Z)  <span class="c"># origin on the plane: mirror mirrors DATA</span>
-        bpy.context.collection.objects.link(wheel)
-        wm = wheel.modifiers.new(<span class="s">&quot;MirrorHalf&quot;</span>, <span class="s">&#x27;MIRROR&#x27;</span>)
-        wm.use_axis[<span class="n">0</span>] = <span class="k">True</span>
-        wm.use_mirror_merge = <span class="k">True</span>
-        wm.merge_threshold = MERGE_THRESHOLD
-        wheels.append(wheel)
-
-    <span class="c"># materials exist in both modes (slot layout is part of the scene contract)</span>
-    <span class="k">for</span> name <span class="k">in</span> (<span class="s">&quot;Paint&quot;</span>, <span class="s">&quot;Glass&quot;</span>, <span class="s">&quot;Trim&quot;</span>, <span class="s">&quot;Tire&quot;</span>, <span class="s">&quot;Hubcap&quot;</span>, <span class="s">&quot;Headlamp&quot;</span>, <span class="s">&quot;Taillamp&quot;</span>):
-        bpy.data.materials.new(name)
-    <span class="k">for</span> mat_name <span class="k">in</span> (<span class="s">&quot;Paint&quot;</span>, <span class="s">&quot;Glass&quot;</span>, <span class="s">&quot;Trim&quot;</span>):
-        body.data.materials.append(bpy.data.materials[mat_name])
-    <span class="k">for</span> w <span class="k">in</span> wheels:
-        <span class="k">for</span> mat_name <span class="k">in</span> (<span class="s">&quot;Tire&quot;</span>, <span class="s">&quot;Hubcap&quot;</span>):
-            w.data.materials.append(bpy.data.materials[mat_name])
-
-    <span class="c"># -- lamps: small mirrored boxes, same origin-on-plane idiom as wheels ---</span>
-    <span class="k">def</span> lamp(name, x0, x1, y0, y1, z0, z1):
-        lme = bpy.data.meshes.new(name + <span class="s">&quot;Half&quot;</span>)
-        bm = bmesh.new()
-        <span class="k">try</span>:
-            bmesh.ops.create_cube(bm, size=<span class="n">1.0</span>)
-            bmesh.ops.scale(bm, vec=(x1 - x0, y1 - y0, z1 - z0), verts=bm.verts)
-            bmesh.ops.translate(bm, vec=((x0 + x1) / <span class="n">2</span>, (y0 + y1) / <span class="n">2</span>, (z0 + z1) / <span class="n">2</span>),
-                                verts=bm.verts)
-            bm.to_mesh(lme)
-        <span class="k">finally</span>:
-            bm.free()
-        ob = bpy.data.objects.new(name, lme)
-        bpy.context.collection.objects.link(ob)  <span class="c"># origin at world origin: on the plane</span>
-        lm = ob.modifiers.new(<span class="s">&quot;MirrorHalf&quot;</span>, <span class="s">&#x27;MIRROR&#x27;</span>)
-        lm.use_axis[<span class="n">0</span>] = <span class="k">True</span>
-        lm.use_mirror_merge = <span class="k">True</span>
-        lm.merge_threshold = MERGE_THRESHOLD
-        ob.data.materials.append(bpy.data.materials[name])
-        <span class="k">return</span> ob
-
-    headlamp = lamp(<span class="s">&quot;Headlamp&quot;</span>, <span class="n">0.38</span>, <span class="n">0.78</span>, -<span class="n">1.97</span>, -<span class="n">1.88</span>, <span class="n">0.40</span>, <span class="n">0.50</span>)
-    taillamp = lamp(<span class="s">&quot;Taillamp&quot;</span>, <span class="n">0.30</span>, <span class="n">0.70</span>, <span class="n">1.97</span>, <span class="n">2.01</span>, <span class="n">0.50</span>, <span class="n">0.62</span>)
-
-    _assign_body_materials(body)
-    _assign_wheel_materials(wheels)
-    <span class="k">return</span> {<span class="s">&quot;body&quot;</span>: body,
-            <span class="s">&quot;mirrored&quot;</span>: [(w, N_WHEEL, F_WHEEL) <span class="k">for</span> w <span class="k">in</span> wheels]
-                        + [(headlamp, <span class="n">8</span>, <span class="n">6</span>), (taillamp, <span class="n">8</span>, <span class="n">6</span>)]}
+        <span class="k">for</span> m <span class="k">in</span> MATERIALS:
+            wme.materials.append(bpy.data.materials[m])
+        wheel = _link_mirrored(<span class="s">&quot;WheelFront&quot;</span> <span class="k">if</span> y &lt; <span class="n">0</span> <span class="k">else</span> <span class="s">&quot;WheelRear&quot;</span>, wme)
+        wheel.location = (<span class="n">0.0</span>, y, TIRE_R)  <span class="c"># origin on the plane: mirror mirrors DATA</span>
+        mirrored.append((wheel, N_WHEEL, F_WHEEL, <span class="n">0</span>))
+
+    M = MATERIALS.index
+    <span class="c"># -- lamps, grille, door mirror: pods seated on the skin, origins on plane</span>
+    hx, hz = <span class="n">0.42</span>, <span class="n">0.645</span>
+    mirrored.append(pod(
+        <span class="s">&quot;Headlamp&quot;</span>, (hx, skin_y(hx, hz), hz), (<span class="n">0.28</span>, -<span class="n">1.0</span>, <span class="n">0.06</span>), <span class="n">0.165</span>, <span class="n">0.054</span>,
+        [(<span class="n">1.0</span>, -<span class="n">0.06</span>), (<span class="n">1.0</span>, <span class="n">0.016</span>), (<span class="n">0.86</span>, <span class="n">0.022</span>), (<span class="n">0.50</span>, <span class="n">0.030</span>)],
+        [M(<span class="s">&quot;Trim&quot;</span>), M(<span class="s">&quot;Chrome&quot;</span>), M(<span class="s">&quot;Chrome&quot;</span>)], M(<span class="s">&quot;Headlamp&quot;</span>), expo=<span class="n">3.2</span>))
+    gz = <span class="n">0.44</span>
+    mirrored.append(pod(   <span class="c"># split pod: authored half, welded whole on the plane</span>
+        <span class="s">&quot;Grille&quot;</span>, (<span class="n">0.0</span>, skin_y(<span class="n">0.15</span>, gz), gz), (<span class="n">0.0</span>, -<span class="n">1.0</span>, <span class="n">0.0</span>), <span class="n">0.31</span>, <span class="n">0.085</span>,
+        [(<span class="n">1.0</span>, -<span class="n">0.05</span>), (<span class="n">1.0</span>, <span class="n">0.022</span>), (<span class="n">0.90</span>, <span class="n">0.022</span>), (<span class="n">0.90</span>, <span class="n">0.006</span>)],
+        [M(<span class="s">&quot;Trim&quot;</span>), M(<span class="s">&quot;Chrome&quot;</span>), M(<span class="s">&quot;Trim&quot;</span>)], M(<span class="s">&quot;Trim&quot;</span>), expo=<span class="n">5.0</span>, split=<span class="k">True</span>))
+    tx, tz = <span class="n">0.50</span>, <span class="n">0.84</span>
+    mirrored.append(pod(
+        <span class="s">&quot;Taillamp&quot;</span>, (tx, skin_y(tx, tz, front=<span class="k">False</span>), tz), (<span class="n">0.30</span>, <span class="n">1.0</span>, <span class="n">0.0</span>),
+        <span class="n">0.15</span>, <span class="n">0.055</span>,
+        [(<span class="n">1.0</span>, -<span class="n">0.05</span>), (<span class="n">1.0</span>, <span class="n">0.012</span>), (<span class="n">0.90</span>, <span class="n">0.018</span>)],
+        [M(<span class="s">&quot;Trim&quot;</span>), M(<span class="s">&quot;Chrome&quot;</span>)], M(<span class="s">&quot;Taillamp&quot;</span>)))
+    my = -<span class="n">0.46</span>
+    mz = half_ring(my)[<span class="n">6</span>][<span class="n">2</span>] + <span class="n">0.075</span>
+    mirrored.append(pod(
+        <span class="s">&quot;DoorMirror&quot;</span>, (<span class="n">0.76</span>, my, mz), (<span class="n">1.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>), <span class="n">0.040</span>, <span class="n">0.026</span>,
+        [(<span class="n">1.0</span>, <span class="n">0.0</span>), (<span class="n">1.0</span>, <span class="n">0.09</span>), (<span class="n">1.9</span>, <span class="n">0.11</span>), (<span class="n">2.1</span>, <span class="n">0.20</span>), (<span class="n">1.6</span>, <span class="n">0.235</span>)],
+        [M(<span class="s">&quot;Trim&quot;</span>), M(<span class="s">&quot;Trim&quot;</span>), M(<span class="s">&quot;Paint&quot;</span>), M(<span class="s">&quot;Paint&quot;</span>)], M(<span class="s">&quot;Paint&quot;</span>),
+        expo=<span class="n">2.6</span>))
+    <span class="k">for</span> name, hy <span class="k">in</span> ((<span class="s">&quot;DoorHandleFront&quot;</span>, <span class="n">0.02</span>), (<span class="s">&quot;DoorHandleRear&quot;</span>, <span class="n">0.66</span>)):
+        hz = half_ring(hy)[<span class="n">5</span>][<span class="n">2</span>] + <span class="n">0.035</span>    <span class="c"># just under the character line</span>
+        mirrored.append(pod(
+            name, (skin_x(hy, hz), hy, hz), (<span class="n">1.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>), <span class="n">0.075</span>, <span class="n">0.016</span>,
+            [(<span class="n">1.0</span>, -<span class="n">0.02</span>), (<span class="n">1.0</span>, <span class="n">0.010</span>), (<span class="n">0.8</span>, <span class="n">0.016</span>)],
+            [M(<span class="s">&quot;Trim&quot;</span>), M(<span class="s">&quot;Chrome&quot;</span>)], M(<span class="s">&quot;Chrome&quot;</span>), up=(<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">1.0</span>)))
+
+    <span class="k">return</span> {<span class="s">&quot;body&quot;</span>: body, <span class="s">&quot;mirrored&quot;</span>: mirrored}
 
 
 <span class="k">def</span> _assign_body_materials(body):
     <span class="s">&quot;&quot;&quot;Deterministic panel classes by construction position (not hand-picked):
-    side windows are ring segment 5 at cabin stations; the windshield and
-    rear window are the full slopes (segments 5..7) at the steepest roof-rise
-    and roof-drop station pairs; pillars/roof sides stay paint, underbody/
-    sill/caps/bumpers are trim, everything else paint.&quot;&quot;&quot;</span>
-    PAINT, GLASS, TRIM = <span class="n">0</span>, <span class="n">1</span>, <span class="n">2</span>
-    n_st = len(STATIONS)
-    dz = [STATIONS[i + <span class="n">1</span>][<span class="n">8</span>] - STATIONS[i][<span class="n">8</span>] <span class="k">for</span> i <span class="k">in</span> range(n_st - <span class="n">1</span>)]
-    shield_pair = max(range(n_st - <span class="n">1</span>), key=<span class="k">lambda</span> i: dz[i])      <span class="c"># windshield slope</span>
-    cabin = [i <span class="k">for</span> i <span class="k">in</span> range(n_st - <span class="n">1</span>)
-             <span class="k">if</span> STATIONS[i][<span class="n">5</span>] &gt;= <span class="n">0.30</span> <span class="k">and</span> STATIONS[i + <span class="n">1</span>][<span class="n">5</span>] &gt;= <span class="n">0.30</span>]
-    rear_pair = min(cabin, key=<span class="k">lambda</span> i: dz[i])                  <span class="c"># rear-window slope</span>
+    underbody, rocker and wheel-arch cladding are trim; the ring segment
+    between sill and glass top is the side glass under the roof (a trim
+    B-pillar interrupts it, paint C-pillar ends it); the drip rail above it
+    is trim and becomes the A-pillar through the windshield; the roof bands
+    are glass exactly where the cabin factor ramps (windshield, hatch).&quot;&quot;&quot;</span>
+    PAINT, GLASS, TRIM = (MATERIALS.index(m) <span class="k">for</span> m <span class="k">in</span> (<span class="s">&quot;Paint&quot;</span>, <span class="s">&quot;Glass&quot;</span>, <span class="s">&quot;Trim&quot;</span>))
     <span class="k">for</span> poly <span class="k">in</span> body.data.polygons:
         i, k = divmod(poly.index, RING - <span class="n">1</span>)
-        <span class="k">if</span> i &gt;= n_st - <span class="n">1</span>:            <span class="c"># cap ngons (front/rear)</span>
-            poly.material_index = TRIM
+        <span class="k">if</span> i &gt;= N_ST - <span class="n">1</span>:            <span class="c"># cap ngons (front/rear fascia)</span>
+            poly.material_index = PAINT
             <span class="k">continue</span>
-        both_cabin = STATIONS[i][<span class="n">5</span>] &gt;= <span class="n">0.30</span> <span class="k">and</span> STATIONS[i + <span class="n">1</span>][<span class="n">5</span>] &gt;= <span class="n">0.30</span>
-        <span class="k">if</span> both_cabin <span class="k">and</span> (k == <span class="n">5</span> <span class="k">or</span> (i <span class="k">in</span> (shield_pair, rear_pair) <span class="k">and</span> <span class="n">5</span> &lt;= k &lt;= <span class="n">7</span>)):
-            poly.material_index = GLASS
-        <span class="k">elif</span> k &lt;= <span class="n">1</span> <span class="k">or</span> (i <span class="k">in</span> (<span class="n">0</span>, n_st - <span class="n">2</span>) <span class="k">and</span> k &lt;= <span class="n">2</span>):
-            poly.material_index = TRIM       <span class="c"># underbody/sill + bumper bands</span>
+        y0, y1 = STATION_Y[i], STATION_Y[i + <span class="n">1</span>]
+        ym = <span class="n">0.5</span> * (y0 + y1)
+        cab = cabin(ym) &gt; <span class="n">1e-6</span>
+        <span class="k">if</span> k &lt;= <span class="n">3</span>:
+            poly.material_index = TRIM       <span class="c"># underbody, rocker, arch cladding</span>
+        <span class="k">elif</span> k == <span class="n">7</span> <span class="k">and</span> cab <span class="k">and</span> ym &lt; Y_CPILLAR:
+            in_b = Y_BPILLAR[<span class="n">0</span>] &lt;= ym &lt;= Y_BPILLAR[<span class="n">1</span>]
+            poly.material_index = TRIM <span class="k">if</span> in_b <span class="k">else</span> GLASS
+        <span class="k">elif</span> k == <span class="n">8</span> <span class="k">and</span> cab <span class="k">and</span> ym &lt; Y_CPILLAR:
+            poly.material_index = TRIM       <span class="c"># drip rail / A-pillar</span>
+        <span class="k">elif</span> k &gt;= <span class="n">9</span> <span class="k">and</span> (Y_COWL &lt;= y0 <span class="k">and</span> y1 &lt;= Y_ROOF0
+                         <span class="k">or</span> Y_ROOF1 &lt;= y0 <span class="k">and</span> y1 &lt;= Y_HATCH):
+            poly.material_index = GLASS      <span class="c"># windshield / hatch glass</span>
         <span class="k">else</span>:
             poly.material_index = PAINT
 
 
-<span class="k">def</span> _assign_wheel_materials(wheels):
-    <span class="k">for</span> w <span class="k">in</span> wheels:
-        <span class="k">for</span> poly <span class="k">in</span> w.data.polygons:
-            j = poly.index // WHEEL_SEG
-            poly.material_index = <span class="n">1</span> <span class="k">if</span> j &gt;= len(WHEEL_RINGS) - <span class="n">2</span> <span class="k">else</span> <span class="n">0</span>
-
-
 <span class="k">def</span> _eval_mesh(obj, dg):
     ev = obj.evaluated_get(dg)
     me = ev.to_mesh()
@@ -658,24 +842,31 @@ <h2>Source</h2>
               <span class="s">f&quot;</span><span class="s">(tol </span>{TOL_BBOX:<span class="s">.1e</span>}<span class="s">)</span><span class="s">&quot;</span>, file=sys.stderr)
         <span class="k">return</span> <span class="n">11</span>
 
-    <span class="c"># 4. mirrored parts (wheels, lamps): each mirrored about an object origin</span>
-    <span class="c"># that sits ON the plane — the data is offset, the object is not</span>
+    <span class="c"># 4. mirrored parts (wheels, lamps, grille, mirrors, handles): each mirrored</span>
+    <span class="c"># about an object origin that sits ON the plane — the data is offset,</span>
+    <span class="c"># the object is not. Offset parts double exactly (2n); the split grille</span>
+    <span class="c"># is authored as a half with `weld` verts on the plane and must weld</span>
+    <span class="c"># like the body (2n - weld), or it renders as two grilles.</span>
     part_lines = []
-    <span class="k">for</span> w, n_half, f_half <span class="k">in</span> objs[<span class="s">&quot;mirrored&quot;</span>]:
+    <span class="k">for</span> w, n_half, f_half, weld <span class="k">in</span> objs[<span class="s">&quot;mirrored&quot;</span>]:
         <span class="k">if</span> abs(w.location.x) &gt; TOL_PLANE:
             print(<span class="s">f&quot;</span><span class="s">ERROR: </span>{w.name}<span class="s"> origin x=</span>{w.location.x}<span class="s"> — mirror mirrors </span><span class="s">&quot;</span>
                   <span class="s">f&quot;</span><span class="s">about the object origin; it must sit on the plane</span><span class="s">&quot;</span>,
                   file=sys.stderr)
             <span class="k">return</span> <span class="n">12</span>
-        <span class="k">if</span> len(w.data.vertices) != n_half <span class="k">or</span> len(w.data.polygons) != f_half:
-            print(<span class="s">f&quot;</span><span class="s">ERROR: </span>{w.name}<span class="s"> datablock </span><span class="s">&quot;</span>
-                  <span class="s">f&quot;</span>{(len(w.data.vertices), len(w.data.polygons))}<span class="s"> != </span><span class="s">&quot;</span>
-                  <span class="s">f&quot;</span>{(n_half, f_half)}<span class="s">&quot;</span>, file=sys.stderr)
+        w_plane = sum(<span class="n">1</span> <span class="k">for</span> v <span class="k">in</span> w.data.vertices
+                      <span class="k">if</span> abs((w.matrix_world @ v.co).x) &lt;= TOL_PLANE)
+        <span class="k">if</span> (len(w.data.vertices), len(w.data.polygons), w_plane) != (n_half, f_half, weld):
+            print(<span class="s">f&quot;</span><span class="s">ERROR: </span>{w.name}<span class="s"> datablock verts/faces/on-plane </span><span class="s">&quot;</span>
+                  <span class="s">f&quot;</span>{(len(w.data.vertices), len(w.data.polygons), w_plane)}<span class="s"> != </span><span class="s">&quot;</span>
+                  <span class="s">f&quot;</span>{(n_half, f_half, weld)}<span class="s">&quot;</span>, file=sys.stderr)
             <span class="k">return</span> <span class="n">13</span>
         wv, _, wf = _eval_mesh(w, dg)
-        <span class="k">if</span> len(wv) != <span class="n">2</span> * n_half <span class="k">or</span> wf != <span class="n">2</span> * f_half:
-            print(<span class="s">f&quot;</span><span class="s">ERROR: </span>{w.name}<span class="s"> evaluated </span>{(len(wv), wf)}<span class="s"> != </span><span class="s">&quot;</span>
-                  <span class="s">f&quot;</span>{(<span class="n">2</span> * n_half, <span class="n">2</span> * f_half)}<span class="s">&quot;</span>, file=sys.stderr)
+        wv_plane = sum(<span class="n">1</span> <span class="k">for</span> v <span class="k">in</span> wv <span class="k">if</span> abs(v.x) &lt;= TOL_PLANE)
+        <span class="k">if</span> len(wv) != <span class="n">2</span> * n_half - weld <span class="k">or</span> wf != <span class="n">2</span> * f_half <span class="k">or</span> wv_plane != weld:
+            print(<span class="s">f&quot;</span><span class="s">ERROR: </span>{w.name}<span class="s"> evaluated verts/faces/on-plane </span><span class="s">&quot;</span>
+                  <span class="s">f&quot;</span>{(len(wv), wf, wv_plane)}<span class="s"> != </span><span class="s">&quot;</span>
+                  <span class="s">f&quot;</span>{(<span class="n">2</span> * n_half - weld, <span class="n">2</span> * f_half, weld)}<span class="s">&quot;</span>, file=sys.stderr)
             <span class="k">return</span> <span class="n">14</span>
         wdev, wlone = _symmetry_dev(wv, TOL_PLANE)
         <span class="k">if</span> wlone <span class="k">or</span> wdev &gt; TOL_SYMM:
@@ -686,7 +877,9 @@ <h2>Source</h2>
             print(<span class="s">f&quot;</span><span class="s">ERROR: </span>{w.name}<span class="s"> evaluated mesh stayed on one side — </span><span class="s">&quot;</span>
                   <span class="s">f&quot;</span><span class="s">mirror produced no mirrored half</span><span class="s">&quot;</span>, file=sys.stderr)
             <span class="k">return</span> <span class="n">16</span>
-        part_lines.append(<span class="s">f&quot;</span>{w.name}<span class="s"> sym_dev=</span>{wdev:<span class="s">.3e</span>}<span class="s">&quot;</span>)
+        part_lines.append(<span class="s">f&quot;</span>{w.name}<span class="s"> </span>{n_half}<span class="s">/</span>{f_half}<span class="s">-&gt;</span>{len(wv)}<span class="s">/</span>{wf}<span class="s">&quot;</span>
+                          + (<span class="s">f&quot;</span><span class="s"> welded=</span>{weld}<span class="s">&quot;</span> <span class="k">if</span> weld <span class="k">else</span> <span class="s">&quot;&quot;</span>)
+                          + <span class="s">f&quot;</span><span class="s"> sym_dev=</span>{wdev:<span class="s">.3e</span>}<span class="s">&quot;</span>)
 
     print(<span class="s">f&quot;</span><span class="s">body half=</span>{got[<span class="n">0</span>]}<span class="s">/</span>{got[<span class="n">1</span>]}<span class="s">/</span>{got[<span class="n">2</span>]}<span class="s"> centerline=</span>{c}<span class="s"> | </span><span class="s">&quot;</span>
           <span class="s">f&quot;</span><span class="s">eval=</span>{len(verts)}<span class="s">/</span>{e_eval}<span class="s">/</span>{f_eval}<span class="s"> euler=2 manifold=True | </span><span class="s">&quot;</span>
@@ -706,41 +899,100 @@ <h2>Source</h2>
         m.use_nodes = <span class="k">True</span>
         <span class="k">return</span> m.node_tree.nodes[<span class="s">&quot;Principled BSDF&quot;</span>]
     p = principled(<span class="s">&quot;Paint&quot;</span>)
-    p.inputs[<span class="s">&quot;Base Color&quot;</span>].default_value = (<span class="n">0.48</span>, <span class="n">0.015</span>, <span class="n">0.022</span>, <span class="n">1.0</span>)
-    p.inputs[<span class="s">&quot;Metallic&quot;</span>].default_value = <span class="n">0.5</span>
-    p.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.32</span>
+    p.inputs[<span class="s">&quot;Base Color&quot;</span>].default_value = (<span class="n">0.50</span>, <span class="n">0.016</span>, <span class="n">0.02</span>, <span class="n">1.0</span>)
+    p.inputs[<span class="s">&quot;Metallic&quot;</span>].default_value = <span class="n">0.0</span>
+    p.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.38</span>
+    p.inputs[<span class="s">&quot;Coat Weight&quot;</span>].default_value = <span class="n">1.0</span>   <span class="c"># clear coat: crisp light streaks</span>
+    p.inputs[<span class="s">&quot;Coat Roughness&quot;</span>].default_value = <span class="n">0.06</span>
     g = principled(<span class="s">&quot;Glass&quot;</span>)
-    <span class="c"># dielectric, not metal: metallic glass mirrors the key light across the</span>
-    <span class="c"># whole windshield and it renders as a hot salmon slab</span>
-    g.inputs[<span class="s">&quot;Base Color&quot;</span>].default_value = (<span class="n">0.02</span>, <span class="n">0.026</span>, <span class="n">0.036</span>, <span class="n">1.0</span>)
+    <span class="c"># opaque dark dielectric, glossy (metallic glass mirrors the key across</span>
+    <span class="c"># the whole windshield as a hot slab). On a near-black stage there is</span>
+    <span class="c"># little to reflect, so a facing-ratio ramp lifts the glass toward steel</span>
+    <span class="c"># blue at grazing angles: tinted glass that reads as glass, not as paint.</span>
+    nt = bpy.data.materials[<span class="s">&quot;Glass&quot;</span>].node_tree
+    lw = nt.nodes.new(<span class="s">&quot;ShaderNodeLayerWeight&quot;</span>)
+    lw.inputs[<span class="s">&quot;Blend&quot;</span>].default_value = <span class="n">0.35</span>
+    ramp = nt.nodes.new(<span class="s">&quot;ShaderNodeValToRGB&quot;</span>)
+    ramp.color_ramp.elements[<span class="n">0</span>].color = (<span class="n">0.010</span>, <span class="n">0.014</span>, <span class="n">0.020</span>, <span class="n">1.0</span>)
+    ramp.color_ramp.elements[<span class="n">1</span>].position = <span class="n">0.9</span>
+    ramp.color_ramp.elements[<span class="n">1</span>].color = (<span class="n">0.11</span>, <span class="n">0.15</span>, <span class="n">0.21</span>, <span class="n">1.0</span>)
+    nt.links.new(lw.outputs[<span class="s">&quot;Facing&quot;</span>], ramp.inputs[<span class="s">&quot;Fac&quot;</span>])
+    nt.links.new(ramp.outputs[<span class="s">&quot;Color&quot;</span>], g.inputs[<span class="s">&quot;Base Color&quot;</span>])
     g.inputs[<span class="s">&quot;Metallic&quot;</span>].default_value = <span class="n">0.0</span>
-    g.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.3</span>
+    g.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.05</span>
+    g.inputs[<span class="s">&quot;Coat Weight&quot;</span>].default_value = <span class="n">1.0</span>
+    g.inputs[<span class="s">&quot;Coat Roughness&quot;</span>].default_value = <span class="n">0.02</span>
     t = principled(<span class="s">&quot;Trim&quot;</span>)
-    t.inputs[<span class="s">&quot;Base Color&quot;</span>].default_value = (<span class="n">0.02</span>, <span class="n">0.021</span>, <span class="n">0.026</span>, <span class="n">1.0</span>)
-    t.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.6</span>
+    t.inputs[<span class="s">&quot;Base Color&quot;</span>].default_value = (<span class="n">0.022</span>, <span class="n">0.023</span>, <span class="n">0.027</span>, <span class="n">1.0</span>)
+    t.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.55</span>
+    ch = principled(<span class="s">&quot;Chrome&quot;</span>)
+    ch.inputs[<span class="s">&quot;Base Color&quot;</span>].default_value = (<span class="n">0.78</span>, <span class="n">0.79</span>, <span class="n">0.82</span>, <span class="n">1.0</span>)
+    ch.inputs[<span class="s">&quot;Metallic&quot;</span>].default_value = <span class="n">1.0</span>
+    ch.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.2</span>
     tire = principled(<span class="s">&quot;Tire&quot;</span>)
-    tire.inputs[<span class="s">&quot;Base Color&quot;</span>].default_value = (<span class="n">0.012</span>, <span class="n">0.013</span>, <span class="n">0.016</span>, <span class="n">1.0</span>)
-    tire.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.85</span>
-    hub = principled(<span class="s">&quot;Hubcap&quot;</span>)
-    hub.inputs[<span class="s">&quot;Base Color&quot;</span>].default_value = (<span class="n">0.62</span>, <span class="n">0.64</span>, <span class="n">0.68</span>, <span class="n">1.0</span>)
-    hub.inputs[<span class="s">&quot;Metallic&quot;</span>].default_value = <span class="n">1.0</span>
-    hub.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.28</span>
+    tire.inputs[<span class="s">&quot;Base Color&quot;</span>].default_value = (<span class="n">0.016</span>, <span class="n">0.016</span>, <span class="n">0.018</span>, <span class="n">1.0</span>)
+    tire.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.82</span>
+    rim = principled(<span class="s">&quot;Rim&quot;</span>)
+    rim.inputs[<span class="s">&quot;Base Color&quot;</span>].default_value = (<span class="n">0.62</span>, <span class="n">0.64</span>, <span class="n">0.68</span>, <span class="n">1.0</span>)
+    rim.inputs[<span class="s">&quot;Metallic&quot;</span>].default_value = <span class="n">1.0</span>
+    rim.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.3</span>
     head = principled(<span class="s">&quot;Headlamp&quot;</span>)
-    head.inputs[<span class="s">&quot;Base Color&quot;</span>].default_value = (<span class="n">0.85</span>, <span class="n">0.9</span>, <span class="n">0.95</span>, <span class="n">1.0</span>)
-    head.inputs[<span class="s">&quot;Emission Color&quot;</span>].default_value = (<span class="n">0.9</span>, <span class="n">0.95</span>, <span class="n">1.0</span>, <span class="n">1.0</span>)
-    head.inputs[<span class="s">&quot;Emission Strength&quot;</span>].default_value = <span class="n">1.2</span>
+    head.inputs[<span class="s">&quot;Base Color&quot;</span>].default_value = (<span class="n">0.8</span>, <span class="n">0.84</span>, <span class="n">0.9</span>, <span class="n">1.0</span>)
+    head.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.1</span>
+    head.inputs[<span class="s">&quot;Emission Color&quot;</span>].default_value = (<span class="n">0.95</span>, <span class="n">0.97</span>, <span class="n">1.0</span>, <span class="n">1.0</span>)
+    head.inputs[<span class="s">&quot;Emission Strength&quot;</span>].default_value = <span class="n">0.6</span>
     tail = principled(<span class="s">&quot;Taillamp&quot;</span>)
-    tail.inputs[<span class="s">&quot;Base Color&quot;</span>].default_value = (<span class="n">0.3</span>, <span class="n">0.008</span>, <span class="n">0.01</span>, <span class="n">1.0</span>)
-    tail.inputs[<span class="s">&quot;Emission Color&quot;</span>].default_value = (<span class="n">0.8</span>, <span class="n">0.02</span>, <span class="n">0.02</span>, <span class="n">1.0</span>)
-    tail.inputs[<span class="s">&quot;Emission Strength&quot;</span>].default_value = <span class="n">0.9</span>
+    tail.inputs[<span class="s">&quot;Base Color&quot;</span>].default_value = (<span class="n">0.35</span>, <span class="n">0.01</span>, <span class="n">0.012</span>, <span class="n">1.0</span>)
+    tail.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.12</span>
+    tail.inputs[<span class="s">&quot;Emission Color&quot;</span>].default_value = (<span class="n">1.0</span>, <span class="n">0.04</span>, <span class="n">0.03</span>, <span class="n">1.0</span>)
+    tail.inputs[<span class="s">&quot;Emission Strength&quot;</span>].default_value = <span class="n">1.2</span>
+
+
+<span class="k">def</span> _shade_smooth(ob, angle_deg=<span class="n">35.0</span>):
+    <span class="s">&quot;&quot;&quot;Smooth shading with sharp edges by dihedral angle and material border.
+
+    Set on the authored half; the Mirror modifier carries the flags across.
+    Boundary edges ON the plane have no partner face in the half, so their
+    angle is the one to the mirror image of their face: acos(1 - 2 nx^2).
+    (The weld itself is not a pixel witness: the hood and roof are nearly
+    flat across the plane, so an unwelded seam renders within 12/255 of the
+    welded one. The 2n - c count is what catches it.)&quot;&quot;&quot;</span>
+    thr = math.radians(angle_deg)
+    bm = bmesh.new()
+    <span class="k">try</span>:
+        bm.from_mesh(ob.data)
+        <span class="k">for</span> f <span class="k">in</span> bm.faces:
+            f.smooth = <span class="k">True</span>
+        <span class="k">for</span> e <span class="k">in</span> bm.edges:
+            lf = e.link_faces
+            <span class="k">if</span> len(lf) == <span class="n">2</span>:
+                sharp = (e.calc_face_angle(<span class="n">0.0</span>) &gt; thr
+                         <span class="k">or</span> lf[<span class="n">0</span>].material_index != lf[<span class="n">1</span>].material_index)
+            <span class="k">elif</span> len(lf) == <span class="n">1</span> <span class="k">and</span> all(abs(v.co.x) &lt;= TOL_PLANE <span class="k">for</span> v <span class="k">in</span> e.verts):
+                nx = lf[<span class="n">0</span>].normal.x
+                sharp = math.acos(max(-<span class="n">1.0</span>, min(<span class="n">1.0</span>, <span class="n">1.0</span> - <span class="n">2.0</span> * nx * nx))) &gt; thr
+            <span class="k">else</span>:
+                sharp = <span class="k">True</span>
+            e.smooth = <span class="k">not</span> sharp
+        bm.to_mesh(ob.data)
+    <span class="k">finally</span>:
+        bm.free()
 
 
 <span class="k">def</span> render_still(objs, path, engine):
+    <span class="c"># Shared Layer 1 gates (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
+
     scene = bpy.context.scene
     _finish_materials()
     body = objs[<span class="s">&quot;body&quot;</span>]
-    <span class="k">for</span> poly <span class="k">in</span> body.data.polygons:
-        poly.use_smooth = <span class="k">False</span>  <span class="c"># crisp loft panels</span>
+    parts = [body] + [w <span class="k">for</span> w, *_ <span class="k">in</span> objs[<span class="s">&quot;mirrored&quot;</span>]]
+    _shade_smooth(body)
+    <span class="k">for</span> ob <span class="k">in</span> parts[<span class="n">1</span>:]:
+        _shade_smooth(ob, <span class="n">40.0</span>)
 
     floor_me = bpy.data.meshes.new(<span class="s">&quot;Floor&quot;</span>)
     bm = bmesh.new()
@@ -764,8 +1016,7 @@ <h2>Source</h2>
 
     world = bpy.data.worlds.new(<span class="s">&quot;World&quot;</span>)
     world.use_nodes = <span class="k">True</span>
-    <span class="c"># metallic paint needs a faint ambient or the flanks die to black</span>
-    world.node_tree.nodes[<span class="s">&quot;Background&quot;</span>].inputs[<span class="s">&quot;Color&quot;</span>].default_value = (<span class="n">0.024</span>, <span class="n">0.026</span>, <span class="n">0.032</span>, <span class="n">1.0</span>)
+    world.node_tree.nodes[<span class="s">&quot;Background&quot;</span>].inputs[<span class="s">&quot;Color&quot;</span>].default_value = (<span class="n">0.02</span>, <span class="n">0.021</span>, <span class="n">0.025</span>, <span class="n">1.0</span>)
     scene.world = world
 
     <span class="k">def</span> light(name, loc, energy, size, col, rot):
@@ -777,21 +1028,20 @@ <h2>Source</h2>
         scene.collection.objects.link(ob)
 
     <span class="c"># default-stage rig per docs/VISUAL-STYLE.md</span>
-    light(<span class="s">&quot;Key&quot;</span>, (-<span class="n">4.0</span>, -<span class="n">5.0</span>, <span class="n">6.0</span>), <span class="n">550.0</span>, <span class="n">5.0</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;Key&quot;</span>, (-<span class="n">4.0</span>, -<span class="n">5.0</span>, <span class="n">6.0</span>), <span class="n">520.0</span>, <span class="n">5.0</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">110.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">3.0</span>, <span class="n">4.5</span>, <span class="n">5.0</span>), <span class="n">320.0</span>, <span class="n">4.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">155</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.76</span>, <span class="n">0.5</span>), (-<span class="n">68</span>, <span class="n">0</span>, <span class="n">190</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">420.0</span>, <span class="n">6.0</span>, (<span class="n">1.0</span>, <span class="n">0.76</span>, <span class="n">0.5</span>), (-<span class="n">68</span>, <span class="n">0</span>, <span class="n">190</span>))
 
     aim = bpy.data.objects.new(<span class="s">&quot;Aim&quot;</span>, <span class="k">None</span>)
-    aim.location = (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.55</span>)
+    aim.location = (<span class="n">0.0</span>, -<span class="n">0.3</span>, <span class="n">0.62</span>)
     scene.collection.objects.link(aim)
     cam_data = bpy.data.cameras.new(<span class="s">&quot;Cam&quot;</span>)
-    cam_data.lens = <span class="n">52.0</span>
+    cam_data.lens = <span class="n">54.0</span>
     cam = bpy.data.objects.new(<span class="s">&quot;Cam&quot;</span>, cam_data)
-    <span class="c"># On the key&#x27;s side (-X): the car is mirror-symmetric, so this is the</span>
-    <span class="c"># same composition, but at +X the camera saw the flank the key cannot</span>
-    <span class="c"># reach and the whole visible side rendered near-black.</span>
-    cam.location = (-<span class="n">4.4</span>, -<span class="n">5.3</span>, <span class="n">2.1</span>)
+    <span class="c"># On the key&#x27;s side (-X), high enough to look down the hood centerline so</span>
+    <span class="c"># both halves — both headlamps, both A-pillars, both wheels — read.</span>
+    cam.location = (-<span class="n">4.3</span>, -<span class="n">5.6</span>, <span class="n">2.7</span>)
     scene.collection.objects.link(cam)
     track = cam.constraints.new(<span class="s">&#x27;TRACK_TO&#x27;</span>)  <span class="c"># data API, not bpy.ops (damped-track-aim)</span>
     track.target = aim
@@ -801,7 +1051,7 @@ <h2>Source</h2>
 
     scene.render.engine = <span class="s">&#x27;CYCLES&#x27;</span> <span class="k">if</span> engine == <span class="s">&#x27;cycles&#x27;</span> <span class="k">else</span> eevee_engine_id()
     <span class="k">if</span> engine == <span class="s">&#x27;cycles&#x27;</span>:
-        scene.cycles.samples = <span class="n">32</span>
+        scene.cycles.samples = <span class="n">64</span>
     <span class="k">else</span>:
         <span class="k">try</span>:
             scene.eevee.taa_render_samples = <span class="n">64</span>
@@ -813,8 +1063,19 @@ <h2>Source</h2>
     scene.render.filepath = path
     <span class="c"># AgX would flatten the candy paint toward chalk (docs/VISUAL-STYLE.md)</span>
     scene.view_settings.view_transform = <span class="s">&#x27;Standard&#x27;</span>
+    bpy.context.view_layer.update()
+
+    <span class="k">if</span> gallery_framing.check_framing(scene, cam, hero=parts, elements=parts,
+                                     stage=[floor, wall]):
+        <span class="k">return</span> <span class="n">17</span>   <span class="c"># the helper&#x27;s 10, remapped: 10 is the partner-deviation check</span>
+    <span class="k">if</span> gallery_asset_quality.check_asset_quality(scene, cam, hero=parts,
+                                                 stage=[floor, wall]):
+        <span class="k">return</span> <span class="n">18</span>   <span class="c"># the helper&#x27;s 11, remapped: 11 is the bbox check</span>
     bpy.ops.render.render(write_still=<span class="k">True</span>)
-    <span class="k">return</span> os.path.exists(path) <span class="k">and</span> os.path.getsize(path) &gt; <span class="n">0</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)
+        <span class="k">return</span> <span class="n">6</span>
+    <span class="k">return</span> <span class="n">0</span>
 
 
 <span class="k">def</span> main():
@@ -833,9 +1094,9 @@ <h2>Source</h2>
         <span class="k">return</span> code
 
     <span class="k">if</span> args.output:
-        <span class="k">if</span> <span class="k">not</span> render_still(objs, os.path.abspath(args.output), args.engine):
-            print(<span class="s">&quot;ERROR: render produced no file&quot;</span>, file=sys.stderr)
-            <span class="k">return</span> <span class="n">6</span>
+        code = render_still(objs, os.path.abspath(args.output), args.engine)
+        <span class="k">if</span> code:
+            <span class="k">return</span> code
         print(<span class="s">f&quot;</span><span class="s">rendered still </span>{args.output}<span class="s">&quot;</span>)
 
     print(<span class="s">&quot;car-mirror-symmetry OK&quot;</span>)
@@ -852,7 +1113,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/car-mirror-symmetry-hero.webp" alt="A red low-poly hatchback with white headlights, modelled as one mirrored half." />
+    <img src="../assets/car-mirror-symmetry-hero.webp" alt="A red stylized hatchback in front three-quarter view with tinted glass, black pillars, spoked wheels, and matched headlamps and door mirrors either side of one centered grille." />
   </dialog>
   <footer>
     <div class="statusbar">
diff --git a/docs/gallery/contact-sheets/car-mirror-symmetry-contact-sheet.webp b/docs/gallery/contact-sheets/car-mirror-symmetry-contact-sheet.webp
index 76844901..33cfa342 100644
Binary files a/docs/gallery/contact-sheets/car-mirror-symmetry-contact-sheet.webp and b/docs/gallery/contact-sheets/car-mirror-symmetry-contact-sheet.webp differ
diff --git a/docs/gallery/index.html b/docs/gallery/index.html
index 679279c9..7fb9c169 100644
--- a/docs/gallery/index.html
+++ b/docs/gallery/index.html
@@ -772,11 +772,11 @@ <h2><a href="soccer-ball-goldberg/">soccer-ball-goldberg</a></h2>
       </article>
       <article class="card" data-tags="modifiers depsgraph">
         <a class="card-media" href="car-mirror-symmetry/" tabindex="-1" aria-hidden="true">
-          <img src="assets/car-mirror-symmetry-hero.webp" alt="A red low-poly hatchback with white headlights, modelled as one mirrored half." loading="lazy" decoding="async" />
+          <img src="assets/car-mirror-symmetry-hero.webp" alt="A red stylized hatchback in front three-quarter view with tinted glass, black pillars, spoked wheels, and matched headlamps and door mirrors either side of one centered grille." loading="lazy" decoding="async" />
         </a>
         <div class="card-body">
           <h2><a href="car-mirror-symmetry/">car-mirror-symmetry</a></h2>
-          <p class="teaches">A generic hatchback lofted as one half (14 stations, 9-point rings) and completed by the Mirror modifier, evaluated through the depsgraph. Wheels and lamps mirror about object origins parked on the symmetry plane.</p>
+          <p class="teaches">A stylized hatchback lofted as one half (52 stations, 13-point rings) and completed by the Mirror modifier, evaluated through the depsgraph. Wheels, lamps, grille, door mirrors and handles mirror about object origins parked on the symmetry plane; the grille is authored as a half and welded on it.</p>
           <p class="witnesses"><span class="tag">witnesses</span> Mirror is a modifier, not applied data: the original keeps the authored half while the evaluated mesh is the welded, watertight, exactly symmetric whole.</p>
           <a class="card-link" href="car-mirror-symmetry/">View example<span class="sr-only"> car-mirror-symmetry</span> <span aria-hidden="true">&rarr;</span></a>
         </div>
diff --git a/examples/car-mirror-symmetry/README.md b/examples/car-mirror-symmetry/README.md
index d4b59baa..b1f5f842 100644
--- a/examples/car-mirror-symmetry/README.md
+++ b/examples/car-mirror-symmetry/README.md
@@ -1,35 +1,43 @@
 # Car Mirror Symmetry
 
-A runnable example that builds a generic hatchback as **one half** — a loft of
-14 stations, each a 9-point half-ring from the bottom centerline out to the
-roof centerline — and completes it with a **Mirror modifier**, evaluated
+A runnable example that builds a stylized hatchback as **one half** — a loft
+of 52 stations, each a 13-point half-ring from the bottom centerline out to
+the roof centerline — and completes it with a **Mirror modifier**, evaluated
 through the depsgraph, following
 [`depsgraph-and-evaluated-data`](../../skills/depsgraph-and-evaluated-data/SKILL.md).
-Wheels and lamps are separate objects mirrored the idiomatic way: the object
-origin sits **on** the symmetry plane and the mesh data is offset — mirror
-mirrors about the object's own origin, so you offset the data, never the
-object.
+Wheels, headlamps, taillamps, grille, door mirrors and door handles are
+separate objects mirrored the idiomatic way: the object origin sits **on**
+the symmetry plane and the mesh data is offset — mirror mirrors about the
+object's own origin, so you offset the data, never the object. The grille is
+the one part authored *across* the plane: a half profile whose end points lie
+exactly on `x = 0`, welded into one grille by the merge.
 
 **What it witnesses:** the original datablock keeps only the authored half
 while the depsgraph carries the mirrored whole, and both directions are
 closed forms:
 
-- **Original holds the half.** Body datablock is exactly 126 verts / 231
-  edges / 106 faces (14 × 9, loft closed forms), with exactly 28 centerline
-  verts (probe: modifier applied into data → exit 3, datablock reads
-  `(224, 434, 212)`).
-- **Evaluated is the welded whole.** Exactly `2n − c = 224` verts (probe:
-  `use_mirror_merge = False` → exit 5, **252** verts — the doubled seam;
-  probe: one centerline vert pulled off the plane → exit 4, **27 ≠ 28**
-  welded; probe: mirror axis off → exit 5, **126** — the half-car). The
+- **Original holds the half.** Body datablock is exactly 676 verts / 1289
+  edges / 614 faces (52 × 13, loft closed forms), with exactly 104
+  centerline verts (probe: modifier applied into data → exit 3, datablock
+  reads `(1248, 2474, 1228)`).
+- **Evaluated is the welded whole.** Exactly `2n − c = 1248` verts (probe:
+  `use_mirror_merge = False` → exit 5, **1352** verts — the doubled seam;
+  probe: one centerline vert pulled off the plane → exit 4, **103 ≠ 104**
+  welded; probe: mirror axis off → exit 5, **676** — the half-car). The
   evaluated shell is watertight (every edge borders 2 faces) with Euler
   characteristic **2** — the two halves weld into a topological sphere.
 - **Exact ±X partners.** Every evaluated vertex has a partner at negated X:
   measured deviation **0.000e+00** (mirror copies exactly; tol 2e-5 guards
   float32), evaluated bbox symmetric (`min.x == −max.x`).
-- **Mirrored parts.** Wheels (96/81 half → 192/162 evaluated) and lamps
-  (8/6 → 16/12) each double across the plane with partner deviation 0.0 —
-  and each object origin reads `x == 0`.
+- **Mirrored parts.** Offset parts double exactly: wheels 390/361 →
+  780/722, headlamp 64/50 → 128/100, taillamp and each handle 48/34 →
+  96/68, door mirror 80/66 → 160/132, partner deviation 0.0, every origin
+  `x == 0` (probe: headlamp origin at `x = 0.01` → exit 12; probe: front
+  wheel's mirror axis off → exit 14, `(390, 361)`). The split grille
+  authors 36 verts with 8 on the plane and must evaluate to `2n − 8 = 64`
+  with exactly 8 on-plane verts (probe: grille merge off → exit 14, **72**
+  verts / 16 on the plane — two grilles; probe: one grille end point moved
+  to `x = 0.004`, beyond the merge threshold → exit 13, 7 ≠ 8 on the plane).
 
 **Why the checks target the modifier, not the base:** mutating a non-plane
 base vertex cannot break the ±X pairing — the evaluated set is always
@@ -37,24 +45,40 @@ base vertex cannot break the ±X pairing — the evaluated set is always
 the modifier (merge off, axis off, modifier applied into data, origin off
 the plane), which is what the probes break.
 
-**Version witness:** check output is byte-identical on Blender 4.5.11 LTS and
-5.1.2. Mirror, `evaluated_get` / `to_mesh` / `to_mesh_clear` (no argument —
-passing the mesh raises TypeError on both), and `TRACK_TO` constraint
-behavior are stable across the pair; only the EEVEE engine id is
-version-gated.
+**Version witness:** check output is byte-identical on Blender 4.5.11 LTS,
+5.1.2 and 5.2.1 LTS. Mirror, `evaluated_get` / `to_mesh` / `to_mesh_clear`
+(no argument — passing the mesh raises TypeError on both), `BVHTree`, and
+`TRACK_TO` constraint behavior are stable across them; only the EEVEE
+engine id is version-gated.
 
 The render is the proof: hide the mirror and the still is literally half a
-car — halved windshield and hood at the centerline, one headlamp. Render
-notes: the loft is faceted by design (flat shading, no bevel modifier — the
-modifier stack is Mirror only, so counts stay closed-form); the window band
-is glass by construction class (steepest roof-rise slope is the windshield,
-steepest drop the rear window, ring segment 5 the side windows), and the
-glass is dielectric — metallic glass mirrors the key light and renders the
-windshield as a hot salmon slab. The camera stands on the key light's side
-of the car: from the other side it saw only the flank the key cannot reach,
-and the whole visible side rendered near-black. The car is mirror-symmetric,
-so the composition is the same either way. The bright streak along the cowl
-below the windshield is the key's highlight in a crease that faces it.
+car — one headlamp, one door mirror, half a grille, a hood cut open at the
+centerline. The camera stands on the key light's side, high enough to look
+down the hood centerline so both halves read at once. The weld itself is
+not a pixel witness — the hood and roof are nearly flat across the plane,
+so an unwelded seam renders within 12/255 of the welded one; the `2n − c`
+count is what catches it.
+
+Render notes: the loft is smooth-shaded with sharp edges set on the
+authored half by dihedral angle (35°) and material border — no bevel or
+weighted-normal modifier, so the stack stays Mirror only and every count
+stays closed-form. Boundary edges on the plane take the angle to their own
+mirror image, `acos(1 − 2nₓ²)`, so the centerline shades smooth. The
+previous faceted loft had a thin pink-white streak on the hood by the
+windshield: not a seam (it sat at `|x|` 0.11–0.38, on the mirrored half, and
+all weld checks passed) but a sliver facet — the loft's greenhouse points
+collapsing onto the hood — flat-shaded and facing the key almost head on
+(`n · −key = 0.967`). The redesigned ring lerps a hood layout into a cabin
+layout, so no such sliver exists. Panel classes are by construction
+position: underbody, rocker and arch cladding are trim; side glass is the
+sill-to-glass-top segment under the roof, broken by a trim B-pillar; the
+drip rail becomes the A-pillar; windshield and hatch glass are the roof
+bands where the cabin factor ramps. The glass is a dark dielectric whose
+base colour ramps toward steel blue at grazing angles (Layer Weight →
+Color Ramp) — on a near-black stage there is little to reflect, and flat
+dark glass read as dull paint. Lamps, grille, mirrors and handles are
+closed superellipse pods seated on the skin by a `BVHTree` ray cast, with a
+chrome bezel and an inset lens rather than flat boxes.
 
 ## Run
 
@@ -90,10 +114,12 @@ against it.
 | 10 | Mirror partner deviation above tolerance |
 | 11 | Evaluated bbox not symmetric about X |
 | 12 | Mirrored-part origin off the plane |
-| 13 | Mirrored-part datablock is not the authored half |
-| 14 | Mirrored-part evaluated counts did not double |
+| 13 | Mirrored-part datablock is not the authored half (verts, faces, on-plane verts) |
+| 14 | Mirrored-part evaluated counts ≠ `2n − weld` / `2f`, or on-plane verts ≠ weld |
 | 15 | Mirrored-part partner check failed |
 | 16 | Mirrored-part evaluated mesh stayed on one side |
+| 17 | Gallery framing violation (`--output` path only; `gallery_framing` returns 10, remapped) |
+| 18 | Asset-quality floor violation (`--output` path only; `gallery_asset_quality` returns 11, remapped) |
 
 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/car-mirror-symmetry/car_mirror_symmetry.py b/examples/car-mirror-symmetry/car_mirror_symmetry.py
index 641b61cd..17f2bfff 100644
--- a/examples/car-mirror-symmetry/car_mirror_symmetry.py
+++ b/examples/car-mirror-symmetry/car_mirror_symmetry.py
@@ -1,4 +1,4 @@
-"""A generic hatchback built as one half and completed by the Mirror modifier
+"""A stylized hatchback built as one half and completed by the Mirror modifier
 — a runnable example.
 
 Witnesses the Mirror + depsgraph contract from depsgraph-and-evaluated-data:
@@ -7,8 +7,9 @@
 2n - c (c = welded centerline verts), every evaluated vertex has an exact
 partner at negated X, the merge threshold actually welds (no doubled
 centerline), the evaluated shell is watertight with Euler characteristic 2,
-and the wheels mirror about their object origins sitting ON the symmetry
-plane. Failure is dramatically visible: a car with one side missing.
+and every separate part (wheels, lamps, grille, mirrors, handles) mirrors about
+an object origin sitting ON the symmetry plane. Failure is dramatically
+visible: a car with one side missing.
 
 ``--no-mirror`` turns off the Mirror X axis on every mirrored object and
 still runs the evaluated-count check, so the half-car fails ``2n − c``.
@@ -22,64 +23,142 @@
     blender --background --python car_mirror_symmetry.py -- --output c.png  # + render
 """
 import bpy, bmesh, sys, os, math, argparse
+from mathutils import Vector
+from mathutils.bvhtree import BVHTree
 
 # --- closed-form construction parameters -----------------------------------
-# 14 loft stations along Y (front at -Y), each a 9-point half-ring from the
-# bottom centerline out and up to the roof centerline. Fields:
-# (y, w_side, z_floor, z_sill, z_side, w_glass, z_glass_base, w_roof, z_roof)
-STATIONS = [
-    (-1.95, 0.74, 0.34, 0.36, 0.52, 0.05, 0.62, 0.04, 0.64),  # nose tip
-    (-1.80, 0.83, 0.30, 0.32, 0.55, 0.08, 0.70, 0.07, 0.73),  # front bumper
-    (-1.65, 0.86, 0.28, 0.28, 0.54, 0.10, 0.72, 0.09, 0.74),
-    (-1.30, 0.87, 0.28, 0.62, 0.66, 0.11, 0.74, 0.10, 0.76),  # front arch peak
-    (-0.95, 0.86, 0.28, 0.28, 0.54, 0.12, 0.78, 0.11, 0.80),
-    (-0.60, 0.85, 0.28, 0.28, 0.55, 0.38, 0.90, 0.34, 0.95),  # hood -> cowl
-    (-0.30, 0.84, 0.28, 0.28, 0.56, 0.54, 1.02, 0.50, 1.30),  # windshield
-    ( 0.20, 0.83, 0.28, 0.28, 0.57, 0.60, 1.05, 0.56, 1.45),  # roof front
-    ( 0.70, 0.83, 0.28, 0.28, 0.57, 0.60, 1.05, 0.55, 1.44),  # roof rear
-    ( 0.95, 0.84, 0.28, 0.28, 0.56, 0.58, 1.04, 0.52, 1.38),
-    ( 1.30, 0.85, 0.28, 0.62, 0.68, 0.50, 1.00, 0.44, 1.24),  # rear arch peak
-    ( 1.65, 0.84, 0.28, 0.28, 0.55, 0.34, 0.95, 0.28, 1.10),  # hatch
-    ( 1.90, 0.80, 0.30, 0.32, 0.53, 0.12, 0.86, 0.11, 0.92),  # tail
-    ( 2.00, 0.72, 0.34, 0.36, 0.50, 0.05, 0.78, 0.04, 0.78),  # rear bumper
-]
-RING = 9                       # points per half-ring, p0 and p8 on the centerline
-WHEEL_SEG = 16
-WHEEL_RINGS = [                # (x, radius) profile: bead, tread, sidewall, rim, cap
-    (0.63, 0.30), (0.67, 0.33), (0.83, 0.33), (0.87, 0.30), (0.89, 0.19), (0.90, 0.15),
-]
-WHEEL_Y = (-1.3, 1.3)          # front / rear axle positions
-WHEEL_Z = 0.33                 # axle height == tire radius: wheels rest on z=0
-
-N_BODY = len(STATIONS) * RING                    # 126
-F_BODY = (len(STATIONS) - 1) * (RING - 1) + 2    # 104 quads + 2 caps
-E_BODY = (len(STATIONS) * (RING - 1)             # ring edges
-          + (len(STATIONS) - 1) * RING           # longitudinal edges
+# The half body is a loft: one 13-point half-ring per station along Y (front
+# at -Y), from the bottom centerline (p0) out and up to the roof centerline
+# (p12). Station Ys are placed, not sampled: every panel edge the design
+# needs (arch openings, cowl, B-pillar, roof end, hatch base) is a station.
+RING = 13
+AXLES = (-1.22, 1.22)          # front / rear axle Y
+TIRE_R = 0.33                  # axle height == tire radius: wheels rest on z=0
+ARCH_R = 0.40                  # wheel-arch opening radius about the axle
+Y_NOSE, Y_TAIL = -1.95, 1.90
+Y_COWL, Y_ROOF0 = -0.60, 0.02  # windshield base / top
+Y_ROOF1, Y_HATCH = 1.30, 1.78  # roof end / hatch-glass base
+Y_BPILLAR = (0.18, 0.30)
+Y_CPILLAR = 1.05
+
+
+def _stations():
+    ys = {Y_NOSE, -1.93, -1.89, -1.83, -1.71,               # rounded nose
+          -0.70, Y_COWL, -0.44, -0.28, -0.13, Y_ROOF0,       # windshield
+          Y_BPILLAR[0], Y_BPILLAR[1], 0.50, 0.70, Y_CPILLAR,
+          Y_ROOF1, 1.74, Y_HATCH, 1.83, 1.87, Y_TAIL}        # hatch + tail
+    for a in AXLES:                                          # arch openings
+        ys.add(round(a - ARCH_R - 0.03, 4))
+        ys.add(round(a + ARCH_R + 0.03, 4))
+        for s in range(13):
+            ys.add(round(a - ARCH_R * math.cos(math.pi * s / 12), 4))
+    return sorted(ys)
+
+
+STATION_Y = _stations()
+N_ST = len(STATION_Y)                            # 52
+N_BODY = N_ST * RING                             # 676
+F_BODY = (N_ST - 1) * (RING - 1) + 2             # 612 quads + 2 caps
+E_BODY = (N_ST * (RING - 1)                      # ring edges
+          + (N_ST - 1) * RING                    # longitudinal edges
           + 2)                                   # cap closing edges
-CENTERLINE = len(STATIONS) * 2                   # p0 + p8 per station: 28
-N_WHEEL = len(WHEEL_RINGS) * WHEEL_SEG           # 96
+CENTERLINE = N_ST * 2                            # p0 + p12 per station: 104
+
+WHEEL_SEG = 30                 # 5 spokes x 6 segments
+WHEEL_RINGS = [                # (x, radius): tire bead -> tread -> rim -> hub cap
+    (0.600, 0.200), (0.605, 0.285), (0.625, 0.322), (0.660, 0.330),
+    (0.840, 0.330), (0.865, 0.322), (0.882, 0.290), (0.886, 0.238),
+    (0.880, 0.224), (0.868, 0.206), (0.868, 0.086), (0.874, 0.064),
+    (0.882, 0.040),
+]
+DISH_RINGS = (9, 10)           # rings whose gap verts recess to form spokes
+DISH_GAP_X = 0.820
+N_WHEEL = len(WHEEL_RINGS) * WHEEL_SEG           # 390
 F_WHEEL = (len(WHEEL_RINGS) - 1) * WHEEL_SEG + 1 # strips + hubcap ngon
 
+POD_P = 16                     # profile points per pod ring (lamps, grille, mirror)
+
 MERGE_THRESHOLD = 1.0e-3
 TOL_SYMM = 2.0e-5    # evaluated partner deviation (float32 storage; mirror copies exact)
 TOL_BBOX = 1.0e-5    # |min.x + max.x| on the evaluated body
 TOL_PLANE = 1.0e-6   # |x| this small counts as on the symmetry plane
 
+MATERIALS = ("Paint", "Glass", "Trim", "Chrome", "Tire", "Rim",
+             "Headlamp", "Taillamp")
+
+
+# --- profile functions (all closed-form in y) ------------------------------
+def _clamp(t):
+    return 0.0 if t < 0.0 else 1.0 if t > 1.0 else t
+
+
+def _ramp(y, y0, y1):
+    return _clamp((y - y0) / (y1 - y0))
+
+
+def _interp(y, pts):
+    if y <= pts[0][0]:
+        return pts[0][1]
+    for (y0, v0), (y1, v1) in zip(pts, pts[1:]):
+        if y <= y1:
+            t = (y - y0) / (y1 - y0)
+            t = t * t * (3.0 - 2.0 * t)          # smoothstep between keys
+            return v0 + (v1 - v0) * t
+    return pts[-1][1]
+
+
+def _round(t):
+    """Quarter-circle rounding: 0 at the very end, 1 once the body is full."""
+    t = _clamp(t)
+    return math.sqrt(max(0.0, 1.0 - (1.0 - t) ** 2))
+
+
+def cabin(y):
+    """0 on hood / rear deck, 1 under the roof, linear through the glass."""
+    return min(_ramp(y, Y_COWL, Y_ROOF0), 1.0 - _ramp(y, Y_ROOF1, Y_HATCH))
+
+
+def half_ring(y):
+    """One 13-point half cross-section at y, bottom centerline -> roof centerline."""
+    rn = min(_round((y - Y_NOSE) / 0.24), _round((Y_TAIL - y) / 0.16))
+    f = 0.70 + 0.30 * rn                     # plan-view corner rounding
+    br = 0.06 * (1.0 - rn)                   # bottom tucks up at the ends
+    td = 0.035 * (1.0 - rn)                  # top rolls down at the ends
+    flare = max(math.exp(-((y - a) / 0.42) ** 2) for a in AXLES)
+    w = (0.84 + 0.04 * flare) * f            # half width, flared over wheels
+    zbelt = _interp(y, [(-1.95, 0.74), (-1.60, 0.80), (-1.22, 0.84),
+                        (-0.60, 0.915), (0.50, 0.945), (1.30, 0.955),
+                        (1.90, 0.935)]) - td
+    ztop = (_interp(y, [(-1.95, 0.80), (-1.60, 0.86), (-1.00, 0.91),
+                        (-0.60, 0.965)]) if y < 0.5 else
+            _interp(y, [(1.30, 1.02), (1.78, 1.01), (1.90, 0.975)])) - td
+    zroof = _interp(y, [(-0.60, 1.32), (0.02, 1.34), (0.60, 1.36),
+                        (1.30, 1.33)])
+    crease = zbelt - 0.15
+    zfloor = 0.20 + br
+
+    d = min((abs(y - a) for a in AXLES))
+    if d <= ARCH_R + 1e-9:                   # inside a wheel-arch opening
+        za = TIRE_R + math.sqrt(max(0.0, ARCH_R ** 2 - d * d))
+        lower = [(0.50, za), (0.93 * w, za), (0.99 * w, za), (w, za + 0.06),
+                 (1.01 * w, max(crease, za + 0.10))]   # cladding flares out
+    else:
+        lower = [(0.50, zfloor), (0.95 * w, 0.24 + br), (0.975 * w, 0.28 + br),
+                 (0.975 * w, 0.36 + 0.5 * br), (1.01 * w, crease)]  # p5: character line
+
+    c = cabin(y)
+    wr = 0.70 * w
+    cab = [(0.93 * w, zbelt + 0.03), (wr + 0.05, zroof - 0.09),
+           (wr, zroof - 0.035), (0.80 * wr, zroof), (0.42 * wr, zroof + 0.018),
+           (0.0, zroof + 0.022)]
+    hood = []
+    for fx in (0.91, 0.80, 0.66, 0.50, 0.27, 0.0):
+        hood.append((fx * w, ztop - (ztop - zbelt) * (fx / 0.965) ** 2))
+    upper = [(h[0] + (k[0] - h[0]) * c, h[1] + (k[1] - h[1]) * c)
+             for h, k in zip(hood, cab)]
 
-def half_ring(st):
-    """One 9-point half cross-section, bottom centerline -> roof centerline."""
-    y, w, zf, zsill, zside, wg, zgb, wr, zroof = st
-    return [
-        (0.0, y, zf),                 # p0 bottom centerline
-        (0.55 * w, y, zf - 0.02),     # p1 underbody
-        (0.95 * w, y, zsill),         # p2 sill (rises over wheel arches)
-        (w, y, zside),                # p3 lower door (widest)
-        (0.99 * w, y, zside + 0.10),  # p4 shoulder
-        (wg, y, zgb),                 # p5 greenhouse base
-        (wr, y, zroof),               # p6 roof edge
-        (0.55 * wr, y, zroof + 0.015),# p7 roof crown
-        (0.0, y, zroof),              # p8 top centerline
-    ]
+    pts = [(0.0, zfloor)] + lower + [(0.965 * w, zbelt)] + upper
+    return [(x, y, z) for x, z in pts]
 
 
 def _newell(pts):
@@ -93,24 +172,105 @@ def _newell(pts):
     return (nx / n, ny / n, nz / n)
 
 
+def _link_mirrored(name, me):
+    """Object at the world origin (ON the plane) + Mirror X with merge."""
+    ob = bpy.data.objects.new(name, me)
+    bpy.context.collection.objects.link(ob)
+    m = ob.modifiers.new("MirrorHalf", 'MIRROR')
+    m.use_axis[0] = True
+    m.use_mirror_merge = True
+    m.merge_threshold = MERGE_THRESHOLD
+    return ob
+
+
+def pod(name, center, normal, half_w, half_h, rings, band_mats, cap_mat,
+        up=(0.0, 0.0, 1.0), expo=4.0, split=False):
+    """Superellipse pod: len(rings) rings, capped at both ends.
+    rings = [(scale, depth along normal)], back to front.
+
+    Offset pod (split=False): POD_P points per closed ring, entirely off the
+    plane. Closed form n = R * POD_P, f = (R - 1) * POD_P + 2, welds 0.
+    Split pod (split=True, center ON the plane, normal in the plane): only
+    the +X half profile, POD_P/2 + 1 points from bottom to top with both
+    ends exactly at x = 0 — the Mirror weld completes it into one part.
+    Closed form n = R * (POD_P/2 + 1), f = (R - 1) * POD_P/2 + 2, welds 2R.
+    Either way the object origin stays on the plane.
+    Returns (object, n_half, f_half, welded)."""
+    n = Vector(normal).normalized()
+    u = Vector(up).cross(n).normalized()
+    v = n.cross(u).normalized()
+    ctr = Vector(center)
+    npts = POD_P // 2 + 1 if split else POD_P
+    nfac = POD_P // 2 if split else POD_P
+    me = bpy.data.meshes.new(name + "Half")
+    bm = bmesh.new()
+    try:
+        rv = []
+        for scale, depth in rings:
+            ring = []
+            for s in range(npts):
+                a = (math.pi * (s / (npts - 1) - 0.5) if split
+                     else 2.0 * math.pi * s / POD_P)
+                ca, sa = math.cos(a), math.sin(a)
+                if split and s in (0, npts - 1):
+                    ca = 0.0                     # exactly on the plane
+                px = math.copysign(abs(ca) ** (2.0 / expo), ca) * half_w * scale
+                py = math.copysign(abs(sa) ** (2.0 / expo), sa) * half_h * scale
+                ring.append(bm.verts.new(ctr + u * px + v * py + n * depth))
+            rv.append(ring)
+        bands = []
+        for b in range(len(rings) - 1):
+            for s in range(nfac):
+                f = bm.faces.new((rv[b][s], rv[b][(s + 1) % npts],
+                                  rv[b + 1][(s + 1) % npts], rv[b + 1][s]))
+                f.material_index = band_mats[b]
+                bands.append(f)
+        back = bm.faces.new(rv[0])
+        back.material_index = band_mats[0]
+        front = bm.faces.new(rv[-1])
+        front.material_index = cap_mat
+        if not split:
+            bmesh.ops.recalc_face_normals(bm, faces=bm.faces)  # closed: outward
+        else:  # open along the plane: orient explicitly
+            side = bands[nfac // 2]          # outboard wall of the first band
+            if side.normal.dot(u) < 0:
+                for f in bands:
+                    f.normal_flip()
+            if front.normal.dot(n) < 0:
+                front.normal_flip()
+            if back.normal.dot(n) > 0:
+                back.normal_flip()
+        bm.to_mesh(me)
+    finally:
+        bm.free()
+    for m in MATERIALS:
+        me.materials.append(bpy.data.materials[m])
+    ob = _link_mirrored(name, me)
+    R = len(rings)
+    return ob, R * npts, (R - 1) * nfac + 2, (2 * R if split else 0)
+
+
 def build_car():
     bpy.ops.wm.read_factory_settings(use_empty=True)
+    for m in MATERIALS:  # exist in both modes (slot layout is part of the scene)
+        bpy.data.materials.new(m)
 
     # -- half body loft ------------------------------------------------------
-    rings = [half_ring(st) for st in STATIONS]
+    rings = [half_ring(y) for y in STATION_Y]
     me = bpy.data.meshes.new("CarBodyHalf")
     bm = bmesh.new()
     try:
         bv = [[bm.verts.new(co) for co in ring] for ring in rings]
         faces = []
-        for i in range(len(STATIONS) - 1):
+        for i in range(N_ST - 1):
             for k in range(RING - 1):
                 faces.append(bm.faces.new(
                     (bv[i][k], bv[i][k + 1], bv[i + 1][k + 1], bv[i + 1][k])))
         caps = [bm.faces.new(bv[0]), bm.faces.new(bv[-1])]
-        # winding: the probe side quad must face +X; flip everything if the
-        # loft convention came out inward (mirror does not fix winding)
-        probe = [v.co for v in (bv[8][3], bv[8][4], bv[9][4], bv[9][3])]
+        # winding: a door quad must face +X; flip everything if the loft
+        # convention came out inward (mirror does not fix winding)
+        mid = N_ST // 2
+        probe = [v.co for v in (bv[mid][4], bv[mid][5], bv[mid + 1][5], bv[mid + 1][4])]
         if _newell(probe)[0] < 0:
             for f in faces + caps:
                 f.normal_flip()
@@ -120,6 +280,8 @@ def build_car():
         if _newell([v.co for v in bv[-1]])[1] < 0:
             caps[1].normal_flip()
         bm.to_mesh(me)
+        bm.faces.ensure_lookup_table()
+        bvh = BVHTree.FromBMesh(bm)  # seats the separate parts on the skin
     finally:
         bm.free()  # the ownership contract from always-free-bmesh
 
@@ -130,110 +292,131 @@ def build_car():
     mirror.use_clip = True            # centerline verts cannot leave x=0
     mirror.use_mirror_merge = True    # weld the two halves shut
     mirror.merge_threshold = MERGE_THRESHOLD
+    for m in MATERIALS:
+        me.materials.append(bpy.data.materials[m])
+    _assign_body_materials(body)
+
+    def skin_y(x, z, front=True):
+        """Y of the body surface at (x, z), probed along the long axis."""
+        o = Vector((x, -5.0 if front else 5.0, z))
+        hit = bvh.ray_cast(o, Vector((0.0, 1.0 if front else -1.0, 0.0)))
+        return hit[0].y
+
+    def skin_x(y, z):
+        """X of the +X flank at (y, z), probed inward from outside."""
+        return bvh.ray_cast(Vector((5.0, y, z)), Vector((-1.0, 0.0, 0.0)))[0].x
 
     # -- wheels: own Mirror each, object origins ON the symmetry plane -------
-    wheels = []
-    for y in WHEEL_Y:
+    mirrored = []
+    for y in AXLES:
         wme = bpy.data.meshes.new("WheelHalf")
         bm = bmesh.new()
         try:
             wr = []
-            for x, r in WHEEL_RINGS:
-                wr.append([bm.verts.new(
-                    (x, r * math.cos(2.0 * math.pi * s / WHEEL_SEG),
-                     r * math.sin(2.0 * math.pi * s / WHEEL_SEG)))
-                    for s in range(WHEEL_SEG)])
+            for j, (x, r) in enumerate(WHEEL_RINGS):
+                ring = []
+                for s in range(WHEEL_SEG):
+                    gap = j in DISH_RINGS and s % 6 in (3, 4, 5)
+                    a = 2.0 * math.pi * s / WHEEL_SEG
+                    ring.append(bm.verts.new((DISH_GAP_X if gap else x,
+                                              r * math.cos(a), r * math.sin(a))))
+                wr.append(ring)
+            strips = []
             for j in range(len(WHEEL_RINGS) - 1):
                 for s in range(WHEEL_SEG):
-                    bm.faces.new((wr[j][s], wr[j][(s + 1) % WHEEL_SEG],
-                                  wr[j + 1][(s + 1) % WHEEL_SEG], wr[j + 1][s]))
-            bm.faces.new(wr[-1])  # hubcap ngon
+                    f = bm.faces.new((wr[j][s], wr[j][(s + 1) % WHEEL_SEG],
+                                      wr[j + 1][(s + 1) % WHEEL_SEG], wr[j + 1][s]))
+                    strips.append(f)
+                    if j <= 6:
+                        f.material_index = MATERIALS.index("Tire")
+                    elif 8 <= j <= 10 and s % 6 in (3, 4):
+                        f.material_index = MATERIALS.index("Trim")   # spoke gaps
+                    else:
+                        f.material_index = MATERIALS.index("Rim")
+            hub = bm.faces.new(wr[-1])
+            hub.material_index = MATERIALS.index("Rim")
+            # tread faces point away from the axle; hub cap faces +X
+            t = strips[3 * WHEEL_SEG]
+            c = t.calc_center_median()
+            if t.normal.dot(Vector((0.0, c.y, c.z))) < 0:
+                for f in strips:
+                    f.normal_flip()
+            if hub.normal.x < 0:
+                hub.normal_flip()
             bm.to_mesh(wme)
         finally:
             bm.free()
-        wheel = bpy.data.objects.new("WheelFront" if y < 0 else "WheelRear", wme)
-        wheel.location = (0.0, y, WHEEL_Z)  # origin on the plane: mirror mirrors DATA
-        bpy.context.collection.objects.link(wheel)
-        wm = wheel.modifiers.new("MirrorHalf", 'MIRROR')
-        wm.use_axis[0] = True
-        wm.use_mirror_merge = True
-        wm.merge_threshold = MERGE_THRESHOLD
-        wheels.append(wheel)
-
-    # materials exist in both modes (slot layout is part of the scene contract)
-    for name in ("Paint", "Glass", "Trim", "Tire", "Hubcap", "Headlamp", "Taillamp"):
-        bpy.data.materials.new(name)
-    for mat_name in ("Paint", "Glass", "Trim"):
-        body.data.materials.append(bpy.data.materials[mat_name])
-    for w in wheels:
-        for mat_name in ("Tire", "Hubcap"):
-            w.data.materials.append(bpy.data.materials[mat_name])
-
-    # -- lamps: small mirrored boxes, same origin-on-plane idiom as wheels ---
-    def lamp(name, x0, x1, y0, y1, z0, z1):
-        lme = bpy.data.meshes.new(name + "Half")
-        bm = bmesh.new()
-        try:
-            bmesh.ops.create_cube(bm, size=1.0)
-            bmesh.ops.scale(bm, vec=(x1 - x0, y1 - y0, z1 - z0), verts=bm.verts)
-            bmesh.ops.translate(bm, vec=((x0 + x1) / 2, (y0 + y1) / 2, (z0 + z1) / 2),
-                                verts=bm.verts)
-            bm.to_mesh(lme)
-        finally:
-            bm.free()
-        ob = bpy.data.objects.new(name, lme)
-        bpy.context.collection.objects.link(ob)  # origin at world origin: on the plane
-        lm = ob.modifiers.new("MirrorHalf", 'MIRROR')
-        lm.use_axis[0] = True
-        lm.use_mirror_merge = True
-        lm.merge_threshold = MERGE_THRESHOLD
-        ob.data.materials.append(bpy.data.materials[name])
-        return ob
-
-    headlamp = lamp("Headlamp", 0.38, 0.78, -1.97, -1.88, 0.40, 0.50)
-    taillamp = lamp("Taillamp", 0.30, 0.70, 1.97, 2.01, 0.50, 0.62)
-
-    _assign_body_materials(body)
-    _assign_wheel_materials(wheels)
-    return {"body": body,
-            "mirrored": [(w, N_WHEEL, F_WHEEL) for w in wheels]
-                        + [(headlamp, 8, 6), (taillamp, 8, 6)]}
+        for m in MATERIALS:
+            wme.materials.append(bpy.data.materials[m])
+        wheel = _link_mirrored("WheelFront" if y < 0 else "WheelRear", wme)
+        wheel.location = (0.0, y, TIRE_R)  # origin on the plane: mirror mirrors DATA
+        mirrored.append((wheel, N_WHEEL, F_WHEEL, 0))
+
+    M = MATERIALS.index
+    # -- lamps, grille, door mirror: pods seated on the skin, origins on plane
+    hx, hz = 0.42, 0.645
+    mirrored.append(pod(
+        "Headlamp", (hx, skin_y(hx, hz), hz), (0.28, -1.0, 0.06), 0.165, 0.054,
+        [(1.0, -0.06), (1.0, 0.016), (0.86, 0.022), (0.50, 0.030)],
+        [M("Trim"), M("Chrome"), M("Chrome")], M("Headlamp"), expo=3.2))
+    gz = 0.44
+    mirrored.append(pod(   # split pod: authored half, welded whole on the plane
+        "Grille", (0.0, skin_y(0.15, gz), gz), (0.0, -1.0, 0.0), 0.31, 0.085,
+        [(1.0, -0.05), (1.0, 0.022), (0.90, 0.022), (0.90, 0.006)],
+        [M("Trim"), M("Chrome"), M("Trim")], M("Trim"), expo=5.0, split=True))
+    tx, tz = 0.50, 0.84
+    mirrored.append(pod(
+        "Taillamp", (tx, skin_y(tx, tz, front=False), tz), (0.30, 1.0, 0.0),
+        0.15, 0.055,
+        [(1.0, -0.05), (1.0, 0.012), (0.90, 0.018)],
+        [M("Trim"), M("Chrome")], M("Taillamp")))
+    my = -0.46
+    mz = half_ring(my)[6][2] + 0.075
+    mirrored.append(pod(
+        "DoorMirror", (0.76, my, mz), (1.0, 0.0, 0.0), 0.040, 0.026,
+        [(1.0, 0.0), (1.0, 0.09), (1.9, 0.11), (2.1, 0.20), (1.6, 0.235)],
+        [M("Trim"), M("Trim"), M("Paint"), M("Paint")], M("Paint"),
+        expo=2.6))
+    for name, hy in (("DoorHandleFront", 0.02), ("DoorHandleRear", 0.66)):
+        hz = half_ring(hy)[5][2] + 0.035    # just under the character line
+        mirrored.append(pod(
+            name, (skin_x(hy, hz), hy, hz), (1.0, 0.0, 0.0), 0.075, 0.016,
+            [(1.0, -0.02), (1.0, 0.010), (0.8, 0.016)],
+            [M("Trim"), M("Chrome")], M("Chrome"), up=(0.0, 0.0, 1.0)))
+
+    return {"body": body, "mirrored": mirrored}
 
 
 def _assign_body_materials(body):
     """Deterministic panel classes by construction position (not hand-picked):
-    side windows are ring segment 5 at cabin stations; the windshield and
-    rear window are the full slopes (segments 5..7) at the steepest roof-rise
-    and roof-drop station pairs; pillars/roof sides stay paint, underbody/
-    sill/caps/bumpers are trim, everything else paint."""
-    PAINT, GLASS, TRIM = 0, 1, 2
-    n_st = len(STATIONS)
-    dz = [STATIONS[i + 1][8] - STATIONS[i][8] for i in range(n_st - 1)]
-    shield_pair = max(range(n_st - 1), key=lambda i: dz[i])      # windshield slope
-    cabin = [i for i in range(n_st - 1)
-             if STATIONS[i][5] >= 0.30 and STATIONS[i + 1][5] >= 0.30]
-    rear_pair = min(cabin, key=lambda i: dz[i])                  # rear-window slope
+    underbody, rocker and wheel-arch cladding are trim; the ring segment
+    between sill and glass top is the side glass under the roof (a trim
+    B-pillar interrupts it, paint C-pillar ends it); the drip rail above it
+    is trim and becomes the A-pillar through the windshield; the roof bands
+    are glass exactly where the cabin factor ramps (windshield, hatch)."""
+    PAINT, GLASS, TRIM = (MATERIALS.index(m) for m in ("Paint", "Glass", "Trim"))
     for poly in body.data.polygons:
         i, k = divmod(poly.index, RING - 1)
-        if i >= n_st - 1:            # cap ngons (front/rear)
-            poly.material_index = TRIM
+        if i >= N_ST - 1:            # cap ngons (front/rear fascia)
+            poly.material_index = PAINT
             continue
-        both_cabin = STATIONS[i][5] >= 0.30 and STATIONS[i + 1][5] >= 0.30
-        if both_cabin and (k == 5 or (i in (shield_pair, rear_pair) and 5 <= k <= 7)):
-            poly.material_index = GLASS
-        elif k <= 1 or (i in (0, n_st - 2) and k <= 2):
-            poly.material_index = TRIM       # underbody/sill + bumper bands
+        y0, y1 = STATION_Y[i], STATION_Y[i + 1]
+        ym = 0.5 * (y0 + y1)
+        cab = cabin(ym) > 1e-6
+        if k <= 3:
+            poly.material_index = TRIM       # underbody, rocker, arch cladding
+        elif k == 7 and cab and ym < Y_CPILLAR:
+            in_b = Y_BPILLAR[0] <= ym <= Y_BPILLAR[1]
+            poly.material_index = TRIM if in_b else GLASS
+        elif k == 8 and cab and ym < Y_CPILLAR:
+            poly.material_index = TRIM       # drip rail / A-pillar
+        elif k >= 9 and (Y_COWL <= y0 and y1 <= Y_ROOF0
+                         or Y_ROOF1 <= y0 and y1 <= Y_HATCH):
+            poly.material_index = GLASS      # windshield / hatch glass
         else:
             poly.material_index = PAINT
 
 
-def _assign_wheel_materials(wheels):
-    for w in wheels:
-        for poly in w.data.polygons:
-            j = poly.index // WHEEL_SEG
-            poly.material_index = 1 if j >= len(WHEEL_RINGS) - 2 else 0
-
-
 def _eval_mesh(obj, dg):
     ev = obj.evaluated_get(dg)
     me = ev.to_mesh()
@@ -351,24 +534,31 @@ def check(objs, no_mirror=False):
               f"(tol {TOL_BBOX:.1e})", file=sys.stderr)
         return 11
 
-    # 4. mirrored parts (wheels, lamps): each mirrored about an object origin
-    # that sits ON the plane — the data is offset, the object is not
+    # 4. mirrored parts (wheels, lamps, grille, mirrors, handles): each mirrored
+    # about an object origin that sits ON the plane — the data is offset,
+    # the object is not. Offset parts double exactly (2n); the split grille
+    # is authored as a half with `weld` verts on the plane and must weld
+    # like the body (2n - weld), or it renders as two grilles.
     part_lines = []
-    for w, n_half, f_half in objs["mirrored"]:
+    for w, n_half, f_half, weld in objs["mirrored"]:
         if abs(w.location.x) > TOL_PLANE:
             print(f"ERROR: {w.name} origin x={w.location.x} — mirror mirrors "
                   f"about the object origin; it must sit on the plane",
                   file=sys.stderr)
             return 12
-        if len(w.data.vertices) != n_half or len(w.data.polygons) != f_half:
-            print(f"ERROR: {w.name} datablock "
-                  f"{(len(w.data.vertices), len(w.data.polygons))} != "
-                  f"{(n_half, f_half)}", file=sys.stderr)
+        w_plane = sum(1 for v in w.data.vertices
+                      if abs((w.matrix_world @ v.co).x) <= TOL_PLANE)
+        if (len(w.data.vertices), len(w.data.polygons), w_plane) != (n_half, f_half, weld):
+            print(f"ERROR: {w.name} datablock verts/faces/on-plane "
+                  f"{(len(w.data.vertices), len(w.data.polygons), w_plane)} != "
+                  f"{(n_half, f_half, weld)}", file=sys.stderr)
             return 13
         wv, _, wf = _eval_mesh(w, dg)
-        if len(wv) != 2 * n_half or wf != 2 * f_half:
-            print(f"ERROR: {w.name} evaluated {(len(wv), wf)} != "
-                  f"{(2 * n_half, 2 * f_half)}", file=sys.stderr)
+        wv_plane = sum(1 for v in wv if abs(v.x) <= TOL_PLANE)
+        if len(wv) != 2 * n_half - weld or wf != 2 * f_half or wv_plane != weld:
+            print(f"ERROR: {w.name} evaluated verts/faces/on-plane "
+                  f"{(len(wv), wf, wv_plane)} != "
+                  f"{(2 * n_half - weld, 2 * f_half, weld)}", file=sys.stderr)
             return 14
         wdev, wlone = _symmetry_dev(wv, TOL_PLANE)
         if wlone or wdev > TOL_SYMM:
@@ -379,7 +569,9 @@ def check(objs, no_mirror=False):
             print(f"ERROR: {w.name} evaluated mesh stayed on one side — "
                   f"mirror produced no mirrored half", file=sys.stderr)
             return 16
-        part_lines.append(f"{w.name} sym_dev={wdev:.3e}")
+        part_lines.append(f"{w.name} {n_half}/{f_half}->{len(wv)}/{wf}"
+                          + (f" welded={weld}" if weld else "")
+                          + f" sym_dev={wdev:.3e}")
 
     print(f"body half={got[0]}/{got[1]}/{got[2]} centerline={c} | "
           f"eval={len(verts)}/{e_eval}/{f_eval} euler=2 manifold=True | "
@@ -399,41 +591,100 @@ def principled(name):
         m.use_nodes = True
         return m.node_tree.nodes["Principled BSDF"]
     p = principled("Paint")
-    p.inputs["Base Color"].default_value = (0.48, 0.015, 0.022, 1.0)
-    p.inputs["Metallic"].default_value = 0.5
-    p.inputs["Roughness"].default_value = 0.32
+    p.inputs["Base Color"].default_value = (0.50, 0.016, 0.02, 1.0)
+    p.inputs["Metallic"].default_value = 0.0
+    p.inputs["Roughness"].default_value = 0.38
+    p.inputs["Coat Weight"].default_value = 1.0   # clear coat: crisp light streaks
+    p.inputs["Coat Roughness"].default_value = 0.06
     g = principled("Glass")
-    # dielectric, not metal: metallic glass mirrors the key light across the
-    # whole windshield and it renders as a hot salmon slab
-    g.inputs["Base Color"].default_value = (0.02, 0.026, 0.036, 1.0)
+    # opaque dark dielectric, glossy (metallic glass mirrors the key across
+    # the whole windshield as a hot slab). On a near-black stage there is
+    # little to reflect, so a facing-ratio ramp lifts the glass toward steel
+    # blue at grazing angles: tinted glass that reads as glass, not as paint.
+    nt = bpy.data.materials["Glass"].node_tree
+    lw = nt.nodes.new("ShaderNodeLayerWeight")
+    lw.inputs["Blend"].default_value = 0.35
+    ramp = nt.nodes.new("ShaderNodeValToRGB")
+    ramp.color_ramp.elements[0].color = (0.010, 0.014, 0.020, 1.0)
+    ramp.color_ramp.elements[1].position = 0.9
+    ramp.color_ramp.elements[1].color = (0.11, 0.15, 0.21, 1.0)
+    nt.links.new(lw.outputs["Facing"], ramp.inputs["Fac"])
+    nt.links.new(ramp.outputs["Color"], g.inputs["Base Color"])
     g.inputs["Metallic"].default_value = 0.0
-    g.inputs["Roughness"].default_value = 0.3
+    g.inputs["Roughness"].default_value = 0.05
+    g.inputs["Coat Weight"].default_value = 1.0
+    g.inputs["Coat Roughness"].default_value = 0.02
     t = principled("Trim")
-    t.inputs["Base Color"].default_value = (0.02, 0.021, 0.026, 1.0)
-    t.inputs["Roughness"].default_value = 0.6
+    t.inputs["Base Color"].default_value = (0.022, 0.023, 0.027, 1.0)
+    t.inputs["Roughness"].default_value = 0.55
+    ch = principled("Chrome")
+    ch.inputs["Base Color"].default_value = (0.78, 0.79, 0.82, 1.0)
+    ch.inputs["Metallic"].default_value = 1.0
+    ch.inputs["Roughness"].default_value = 0.2
     tire = principled("Tire")
-    tire.inputs["Base Color"].default_value = (0.012, 0.013, 0.016, 1.0)
-    tire.inputs["Roughness"].default_value = 0.85
-    hub = principled("Hubcap")
-    hub.inputs["Base Color"].default_value = (0.62, 0.64, 0.68, 1.0)
-    hub.inputs["Metallic"].default_value = 1.0
-    hub.inputs["Roughness"].default_value = 0.28
+    tire.inputs["Base Color"].default_value = (0.016, 0.016, 0.018, 1.0)
+    tire.inputs["Roughness"].default_value = 0.82
+    rim = principled("Rim")
+    rim.inputs["Base Color"].default_value = (0.62, 0.64, 0.68, 1.0)
+    rim.inputs["Metallic"].default_value = 1.0
+    rim.inputs["Roughness"].default_value = 0.3
     head = principled("Headlamp")
-    head.inputs["Base Color"].default_value = (0.85, 0.9, 0.95, 1.0)
-    head.inputs["Emission Color"].default_value = (0.9, 0.95, 1.0, 1.0)
-    head.inputs["Emission Strength"].default_value = 1.2
+    head.inputs["Base Color"].default_value = (0.8, 0.84, 0.9, 1.0)
+    head.inputs["Roughness"].default_value = 0.1
+    head.inputs["Emission Color"].default_value = (0.95, 0.97, 1.0, 1.0)
+    head.inputs["Emission Strength"].default_value = 0.6
     tail = principled("Taillamp")
-    tail.inputs["Base Color"].default_value = (0.3, 0.008, 0.01, 1.0)
-    tail.inputs["Emission Color"].default_value = (0.8, 0.02, 0.02, 1.0)
-    tail.inputs["Emission Strength"].default_value = 0.9
+    tail.inputs["Base Color"].default_value = (0.35, 0.01, 0.012, 1.0)
+    tail.inputs["Roughness"].default_value = 0.12
+    tail.inputs["Emission Color"].default_value = (1.0, 0.04, 0.03, 1.0)
+    tail.inputs["Emission Strength"].default_value = 1.2
+
+
+def _shade_smooth(ob, angle_deg=35.0):
+    """Smooth shading with sharp edges by dihedral angle and material border.
+
+    Set on the authored half; the Mirror modifier carries the flags across.
+    Boundary edges ON the plane have no partner face in the half, so their
+    angle is the one to the mirror image of their face: acos(1 - 2 nx^2).
+    (The weld itself is not a pixel witness: the hood and roof are nearly
+    flat across the plane, so an unwelded seam renders within 12/255 of the
+    welded one. The 2n - c count is what catches it.)"""
+    thr = math.radians(angle_deg)
+    bm = bmesh.new()
+    try:
+        bm.from_mesh(ob.data)
+        for f in bm.faces:
+            f.smooth = True
+        for e in bm.edges:
+            lf = e.link_faces
+            if len(lf) == 2:
+                sharp = (e.calc_face_angle(0.0) > thr
+                         or lf[0].material_index != lf[1].material_index)
+            elif len(lf) == 1 and all(abs(v.co.x) <= TOL_PLANE for v in e.verts):
+                nx = lf[0].normal.x
+                sharp = math.acos(max(-1.0, min(1.0, 1.0 - 2.0 * nx * nx))) > thr
+            else:
+                sharp = True
+            e.smooth = not sharp
+        bm.to_mesh(ob.data)
+    finally:
+        bm.free()
 
 
 def render_still(objs, path, engine):
+    # Shared Layer 1 gates (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
+
     scene = bpy.context.scene
     _finish_materials()
     body = objs["body"]
-    for poly in body.data.polygons:
-        poly.use_smooth = False  # crisp loft panels
+    parts = [body] + [w for w, *_ in objs["mirrored"]]
+    _shade_smooth(body)
+    for ob in parts[1:]:
+        _shade_smooth(ob, 40.0)
 
     floor_me = bpy.data.meshes.new("Floor")
     bm = bmesh.new()
@@ -457,8 +708,7 @@ def render_still(objs, path, engine):
 
     world = bpy.data.worlds.new("World")
     world.use_nodes = True
-    # metallic paint needs a faint ambient or the flanks die to black
-    world.node_tree.nodes["Background"].inputs["Color"].default_value = (0.024, 0.026, 0.032, 1.0)
+    world.node_tree.nodes["Background"].inputs["Color"].default_value = (0.02, 0.021, 0.025, 1.0)
     scene.world = world
 
     def light(name, loc, energy, size, col, rot):
@@ -470,21 +720,20 @@ def light(name, loc, energy, size, col, rot):
         scene.collection.objects.link(ob)
 
     # default-stage rig per docs/VISUAL-STYLE.md
-    light("Key", (-4.0, -5.0, 6.0), 550.0, 5.0, (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("Key", (-4.0, -5.0, 6.0), 520.0, 5.0, (1.0, 0.96, 0.9), (48, 0, -35))
+    light("Fill", (5.0, -3.5, 2.5), 110.0, 9.0, (0.75, 0.85, 1.0), (65, 0, 50))
     light("Rim", (3.0, 4.5, 5.0), 320.0, 4.0, (0.6, 0.78, 1.0), (-55, 0, 155))
-    light("Wedge", (2.5, 5.5, 4.0), 400.0, 6.0, (1.0, 0.76, 0.5), (-68, 0, 190))
+    light("Wedge", (2.5, 5.5, 4.0), 420.0, 6.0, (1.0, 0.76, 0.5), (-68, 0, 190))
 
     aim = bpy.data.objects.new("Aim", None)
-    aim.location = (0.0, 0.0, 0.55)
+    aim.location = (0.0, -0.3, 0.62)
     scene.collection.objects.link(aim)
     cam_data = bpy.data.cameras.new("Cam")
-    cam_data.lens = 52.0
+    cam_data.lens = 54.0
     cam = bpy.data.objects.new("Cam", cam_data)
-    # On the key's side (-X): the car is mirror-symmetric, so this is the
-    # same composition, but at +X the camera saw the flank the key cannot
-    # reach and the whole visible side rendered near-black.
-    cam.location = (-4.4, -5.3, 2.1)
+    # On the key's side (-X), high enough to look down the hood centerline so
+    # both halves — both headlamps, both A-pillars, both wheels — read.
+    cam.location = (-4.3, -5.6, 2.7)
     scene.collection.objects.link(cam)
     track = cam.constraints.new('TRACK_TO')  # data API, not bpy.ops (damped-track-aim)
     track.target = aim
@@ -494,7 +743,7 @@ def light(name, loc, energy, size, col, rot):
 
     scene.render.engine = 'CYCLES' if engine == 'cycles' else eevee_engine_id()
     if engine == 'cycles':
-        scene.cycles.samples = 32
+        scene.cycles.samples = 64
     else:
         try:
             scene.eevee.taa_render_samples = 64
@@ -506,8 +755,19 @@ def light(name, loc, energy, size, col, rot):
     scene.render.filepath = path
     # AgX would flatten the candy paint toward chalk (docs/VISUAL-STYLE.md)
     scene.view_settings.view_transform = 'Standard'
+    bpy.context.view_layer.update()
+
+    if gallery_framing.check_framing(scene, cam, hero=parts, elements=parts,
+                                     stage=[floor, wall]):
+        return 17   # the helper's 10, remapped: 10 is the partner-deviation check
+    if gallery_asset_quality.check_asset_quality(scene, cam, hero=parts,
+                                                 stage=[floor, wall]):
+        return 18   # the helper's 11, remapped: 11 is the bbox check
     bpy.ops.render.render(write_still=True)
-    return os.path.exists(path) and os.path.getsize(path) > 0
+    if not (os.path.exists(path) and os.path.getsize(path) > 0):
+        print("ERROR: render produced no file", file=sys.stderr)
+        return 6
+    return 0
 
 
 def main():
@@ -526,9 +786,9 @@ def main():
         return code
 
     if args.output:
-        if not render_still(objs, os.path.abspath(args.output), args.engine):
-            print("ERROR: render produced no file", file=sys.stderr)
-            return 6
+        code = render_still(objs, os.path.abspath(args.output), args.engine)
+        if code:
+            return code
         print(f"rendered still {args.output}")
 
     print("car-mirror-symmetry OK")
diff --git a/examples/car-mirror-symmetry/preview.webp b/examples/car-mirror-symmetry/preview.webp
index 4d916e18..d745ee39 100644
Binary files a/examples/car-mirror-symmetry/preview.webp and b/examples/car-mirror-symmetry/preview.webp differ
diff --git a/examples/gallery.json b/examples/gallery.json
index 94b065de..34ae39ae 100644
--- a/examples/gallery.json
+++ b/examples/gallery.json
@@ -529,8 +529,8 @@
     {
       "name": "car-mirror-symmetry",
       "dir": "examples/car-mirror-symmetry",
-      "teaches": "A generic hatchback lofted as one half (14 stations, 9-point rings) and completed by the Mirror modifier, evaluated through the depsgraph. Wheels and lamps mirror about object origins parked on the symmetry plane.",
-      "alt": "A red low-poly hatchback with white headlights, modelled as one mirrored half.",
+      "teaches": "A stylized hatchback lofted as one half (52 stations, 13-point rings) and completed by the Mirror modifier, evaluated through the depsgraph. Wheels, lamps, grille, door mirrors and handles mirror about object origins parked on the symmetry plane; the grille is authored as a half and welded on it.",
+      "alt": "A red stylized hatchback in front three-quarter view with tinted glass, black pillars, spoked wheels, and matched headlamps and door mirrors either side of one centered grille.",
       "witnessesFix": "Mirror is a modifier, not applied data: the original keeps the authored half while the evaluated mesh is the welded, watertight, exactly symmetric whole.",
       "hero": "docs/gallery/assets/car-mirror-symmetry-hero.webp",
       "preview": "examples/car-mirror-symmetry/preview.webp",
diff --git a/scripts/asset_sheet.py b/scripts/asset_sheet.py
index eea651bb..4766028e 100644
--- a/scripts/asset_sheet.py
+++ b/scripts/asset_sheet.py
@@ -65,6 +65,8 @@
     "grain-sacks": (r"^SacksLow$", None),
     "rope-bridge": (r"^BridgeLow$", None),
     "wheelbarrow": (r"^BarrowLow$", None),
+    "car-mirror-symmetry": (r"^(CarBody|Wheel(Front|Rear)|Headlamp|Taillamp|Grille"
+                            r"|DoorMirror|DoorHandle(Front|Rear))$", None),
     "export-preset-axis": (r"^RadioMast\.Unity$", None),
 }