diff --git a/README.md b/README.md
index b093f18a..2507a446 100644
--- a/README.md
+++ b/README.md
@@ -971,7 +971,7 @@ concave grooves are free.
 </tr>
 <tr>
 <td width="46%" valign="middle">
-<a href="examples/custom-normals-shade/"><img src="examples/custom-normals-shade/preview.webp" alt="Custom normals and shade by angle: three olive-drab jerry can props with pressed X ribs and red spout rings on a dark studio floor - one faceted flat, one smeared by smooth-everything, one crisp with correct hard edges - proving the post-4.1 shading contract" /></a>
+<a href="examples/custom-normals-shade/"><img src="examples/custom-normals-shade/preview.webp" alt="Custom normals and shade by angle: three olive-drab jerry cans with X-pressed panels, triple handles and red-sealed spouts on a dark studio floor - one faceted flat, one smeared glossy by smooth-everything, one crisp by-angle with its sharp edges traced in thin cyan lines - proving the post-4.1 shading contract" /></a>
 </td>
 <td valign="middle">
 
@@ -984,7 +984,7 @@ on **both** 4.5 LTS and 5.1. `set_sharp_from_angle` marks sharp exactly the
 edges an independent dihedral recompute predicts; evaluated loop normals
 weld across smooth edges and split by the dihedral across sharp ones;
 custom split normals survive depsgraph evaluation within their int16
-quantization (1.407e-04, not float-exact). Documents the legacy
+quantization (3.904e-05, not float-exact). Documents the legacy
 `shade_auto_smooth` operator trap: CANCELLED headless on 4.5, FINISHED
 with the Smooth-by-Angle modifier on 5.1.
 
diff --git a/docs/gallery/asset-sheets/custom-normals-shade.webp b/docs/gallery/asset-sheets/custom-normals-shade.webp
new file mode 100644
index 00000000..fd6e67d3
Binary files /dev/null and b/docs/gallery/asset-sheets/custom-normals-shade.webp differ
diff --git a/docs/gallery/assets/custom-normals-shade-hero.webp b/docs/gallery/assets/custom-normals-shade-hero.webp
index 00dbfe1d..93f2f039 100644
Binary files a/docs/gallery/assets/custom-normals-shade-hero.webp and b/docs/gallery/assets/custom-normals-shade-hero.webp differ
diff --git a/docs/gallery/contact-sheets/custom-normals-shade-contact-sheet.webp b/docs/gallery/contact-sheets/custom-normals-shade-contact-sheet.webp
index b5ad0a09..c34a794c 100644
Binary files a/docs/gallery/contact-sheets/custom-normals-shade-contact-sheet.webp and b/docs/gallery/contact-sheets/custom-normals-shade-contact-sheet.webp differ
diff --git a/docs/gallery/custom-normals-shade/index.html b/docs/gallery/custom-normals-shade/index.html
index 0cf3e3d2..0d557c67 100644
--- a/docs/gallery/custom-normals-shade/index.html
+++ b/docs/gallery/custom-normals-shade/index.html
@@ -4,25 +4,25 @@
   <meta charset="utf-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1" />
   <title>custom-normals-shade — Examples — Blender Developer Tools</title>
-  <meta name="description" content="A jerry can prop shaded three ways to prove the post-4.1 shading contract: hard edges are mesh data, landing exactly where the dihedral crosses. Face smooth flags plus a sharp_edge attribute, verified against an independently recomputed dihedral test, and per-loop custom normals surviving depsgraph evaluation within their int16 storage quantization (1.407e-04, not float-exact)." />
+  <meta name="description" content="A jerry can prop shaded three ways to prove the post-4.1 shading contract: hard edges are mesh data, landing exactly where the dihedral crosses. Face smooth flags plus a sharp_edge attribute, verified against an independently recomputed dihedral test, and per-loop custom normals surviving depsgraph evaluation within their int16 storage quantization (3.904e-05 over 8196 loops, not float-exact)." />
   <link rel="canonical" href="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/custom-normals-shade/" />
   <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="custom-normals-shade — Examples — Blender Developer Tools" />
-  <meta property="og:description" content="A jerry can prop shaded three ways to prove the post-4.1 shading contract: hard edges are mesh data, landing exactly where the dihedral crosses. Face smooth flags plus a sharp_edge attribute, verified against an independently recomputed dihedral test, and per-loop custom normals surviving depsgraph evaluation within their int16 storage quantization (1.407e-04, not float-exact)." />
+  <meta property="og:description" content="A jerry can prop shaded three ways to prove the post-4.1 shading contract: hard edges are mesh data, landing exactly where the dihedral crosses. Face smooth flags plus a sharp_edge attribute, verified against an independently recomputed dihedral test, and per-loop custom normals surviving depsgraph evaluation within their int16 storage quantization (3.904e-05 over 8196 loops, not float-exact)." />
   <meta property="og:url" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/custom-normals-shade/" />
   <meta property="og:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/custom-normals-shade-hero.webp" />
   <meta property="og:image:width" content="1280" />
   <meta property="og:image:height" content="720" />
-  <meta property="og:image:alt" content="Three olive jerry cans with embossed X ribs, shaded flat, smooth and smooth-by-angle." />
+  <meta property="og:image:alt" content="Three olive jerry cans with X-pressed panels, triple handles and red-sealed spouts: faceted flat, glossy-smeared smooth-everywhere, and crisp by-angle with its sharp edges traced in thin cyan lines." />
   <meta property="og:site_name" content="Blender Developer Tools" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="custom-normals-shade — Examples — Blender Developer Tools" />
-  <meta name="twitter:description" content="A jerry can prop shaded three ways to prove the post-4.1 shading contract: hard edges are mesh data, landing exactly where the dihedral crosses. Face smooth flags plus a sharp_edge attribute, verified against an independently recomputed dihedral test, and per-loop custom normals surviving depsgraph evaluation within their int16 storage quantization (1.407e-04, not float-exact)." />
+  <meta name="twitter:description" content="A jerry can prop shaded three ways to prove the post-4.1 shading contract: hard edges are mesh data, landing exactly where the dihedral crosses. Face smooth flags plus a sharp_edge attribute, verified against an independently recomputed dihedral test, and per-loop custom normals surviving depsgraph evaluation within their int16 storage quantization (3.904e-05 over 8196 loops, not float-exact)." />
   <meta name="twitter:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/custom-normals-shade-hero.webp" />
-  <meta name="twitter:image:alt" content="Three olive jerry cans with embossed X ribs, shaded flat, smooth and smooth-by-angle." />
+  <meta name="twitter:image:alt" content="Three olive jerry cans with X-pressed panels, triple handles and red-sealed spouts: faceted flat, glossy-smeared smooth-everywhere, and crisp by-angle with its sharp edges traced in thin cyan lines." />
   <style>
     /* fonts are deployed by the landing build (docs/fonts/) */
     @font-face { font-family: 'Barlow Condensed'; font-weight: 600; font-display: swap;
@@ -265,27 +265,27 @@
   </div>
   <header class="hero">
     <h1>custom-normals-shade</h1>
-    <p>A jerry can prop shaded three ways to prove the post-4.1 shading contract: hard edges are mesh data, landing exactly where the dihedral crosses. Face smooth flags plus a sharp_edge attribute, verified against an independently recomputed dihedral test, and per-loop custom normals surviving depsgraph evaluation within their int16 storage quantization (1.407e-04, not float-exact).</p>
+    <p>A jerry can prop shaded three ways to prove the post-4.1 shading contract: hard edges are mesh data, landing exactly where the dihedral crosses. Face smooth flags plus a sharp_edge attribute, verified against an independently recomputed dihedral test, and per-loop custom normals surviving depsgraph evaluation within their int16 storage quantization (3.904e-05 over 8196 loops, not float-exact).</p>
   </header>
   <main id="main">
-    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: Three olive jerry cans with embossed X ribs, shaded flat, smooth and smooth-by-angle.">
-      <img src="../assets/custom-normals-shade-hero.webp" alt="Three olive jerry cans with embossed X ribs, shaded flat, smooth and smooth-by-angle." width="1280" height="720" />
+    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: Three olive jerry cans with X-pressed panels, triple handles and red-sealed spouts: faceted flat, glossy-smeared smooth-everywhere, and crisp by-angle with its sharp edges traced in thin cyan lines.">
+      <img src="../assets/custom-normals-shade-hero.webp" alt="Three olive jerry cans with X-pressed panels, triple handles and red-sealed spouts: faceted flat, glossy-smeared smooth-everywhere, and crisp by-angle with its sharp edges traced in thin cyan lines." 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> use_auto_smooth, use_custom_normals and calc_normals are AttributeError on BOTH 4.5 LTS and 5.1 - AI code still emits them. The legacy shade_auto_smooth operator CANCELS headless on 4.5 (asset load never finishes; mesh untouched; no exception) while 5.1 FINISHES with the Smooth by Angle NODES modifier. By-angle sharp sets match the independent dihedral recompute exactly (188 of 388 edges over 3 meshes).</div>
+    <div class="callout"><span class="tag">witnesses</span> use_auto_smooth, use_custom_normals and calc_normals are AttributeError on BOTH 4.5 LTS and 5.1 - AI code still emits them. The legacy shade_auto_smooth operator CANCELS headless on 4.5 (asset load never finishes; mesh untouched; no exception) while 5.1 FINISHES with the Smooth by Angle NODES modifier. By-angle sharp sets match the independent dihedral recompute exactly (1304 of 4738 edges over 3 meshes).</div>
     <div class="runline">
       <pre id="runCmd">blender --background --python examples/custom-normals-shade/custom_normals_shade.py --</pre>
       <button class="copy-btn" id="copyRun" type="button">Copy</button>
     </div>
     <section class="detail-section md">
-<p>A runnable example that builds a jerry can prop — rounded-slab shell, pressed X ribs, spout and cap, three-post handle — and verifies the shading contract a game prop&#x27;s silhouette depends on: which edges read hard and which read smooth is mesh DATA, carried since Blender 4.1 by face smooth flags plus a <code>sharp_edge</code> attribute, following <a href="https://github.com/TMHSDigital/Blender-Developer-Tools/tree/main/skills/mesh-editing-and-bmesh/SKILL.md"><code>mesh-editing-and-bmesh</code></a>.</p>
+<p>A runnable example that builds a jerry can prop — a pressed-steel shell whose front and back carry four raised rounded-triangle panels (the X is the channel between them), a weld-seam bead round the side band, a triple carry handle on welded feet, and a spout with red seal, domed cap, cam lever, hinge and locking pin; olive paint chipped to steel on exposed edges by a <code>wear</code> point attribute — and verifies the shading contract a game prop&#x27;s silhouette depends on: which edges read hard and which read smooth is mesh DATA, carried since Blender 4.1 by face smooth flags plus a <code>sharp_edge</code> attribute, following <a href="https://github.com/TMHSDigital/Blender-Developer-Tools/tree/main/skills/mesh-editing-and-bmesh/SKILL.md"><code>mesh-editing-and-bmesh</code></a>.</p>
 <p><strong>Pipeline arc neighbor:</strong> collision in <a href="https://github.com/TMHSDigital/Blender-Developer-Tools/tree/main/examples/collision-hull-proxy"><code>collision-hull-proxy</code></a> (the pair partner — same prop-pipeline audience), tangent space in <a href="https://github.com/TMHSDigital/Blender-Developer-Tools/tree/main/examples/triangulate-tangents"><code>triangulate-tangents</code></a> — normal maps are baked against exactly this shading, and engines harden or soften the same edges at ingest.</p>
 <p><strong>Scope:</strong> this witnesses the bpy-level contract a prop pipeline relies on. It is not an engine exporter and does not claim engine/FiveM compatibility — it proves the mesh-data properties such an asset&#x27;s shading must have.</p>
 <p><strong>What it witnesses:</strong></p>
-<ul><li><strong>The legacy shading API is gone — on both supported versions.</strong> <code>use_auto_smooth</code>, <code>use_custom_normals</code>, and <code>calc_normals</code> are AttributeError on 4.5 LTS <em>and</em> 5.1. AI-generated Blender code still emits <code>mesh.use_auto_smooth = True</code> constantly; any script carrying that habit dies immediately, and this check keeps it dead.</li><li><strong>Shade-by-angle is exact.</strong> <code>mesh.set_sharp_from_angle(30°)</code> (which also sets the face smooth flags — probed on both versions) marks sharp exactly the edges whose <em>independently recomputed</em> dihedral angle crosses the threshold: Shell 48 of 72 edges, rib 12 of 12, neck 128 of 304 — an exact set match, not a count approximation.</li><li><strong>The evaluated shading matches the attribute&#x27;s promise.</strong> Through depsgraph evaluation, loop normals across a smooth edge are welded (deviation 0.0, tol 1e-3) and loop normals across a sharp edge carry their face normals split by exactly the dihedral (angle error 0.0 rad, tol 5e-3), all unit length (err 5.6e-08).</li><li><strong>Custom split normals survive depsgraph evaluation</strong> — with a quantization budget, not float precision: <code>normals_split_custom_set</code> stores per-loop normals in int16, so a 144-loop round-trip reads back within <strong>1.407e-04</strong> (tol 2e-4), unit length within 1.1e-07. Asserting float-exact custom normals is a real bug this check catches.</li><li><strong>The divergence: the legacy <code>shade_auto_smooth</code> OPERATOR is a version-split trap.</strong> It builds the Smooth-by-Angle node-group modifier from a bundled asset. Headless on <strong>4.5 LTS the asset load never finishes</strong>: the op returns <code>{&#x27;CANCELLED&#x27;}</code> — no exception — and the mesh stays <strong>untouched</strong> (measured: 0 smooth faces, 0 modifiers). Any script that ignores the return set ships flat shading and never knows. On <strong>5.1</strong> it FINISHES and adds the <code>Smooth by Angle</code> NODES modifier. The portable path is the data API above, version-gated here explicitly.</li></ul>
-<p><strong>What each check catches on failure:</strong> author/audit threshold drift (probe: sharp marks applied at 20° but audited at 30°, exit 5, 4 extra edges); the two halves of the contract out of sync (probe: <code>sharp_edge</code> set but face smooth flags lost, exit 6, smooth-edge loops split by 3.83e-01); float-exactness assumed of custom normals (probe: tolerance 1e-6, exit 7, measured 1.407e-04); and any future version that resurrects the legacy API or changes the operator&#x27;s headless behavior (exit 3/8).</p>
-<p><strong>Version witness:</strong> every value above is identical on Blender 4.5.11 LTS and 5.1.2 except the <code>shade_auto_smooth</code> operator behavior, which is asserted per version (CANCELLED + untouched on 4.5, FINISHED + NODES modifier on 5.1).</p>
-<p>The render shows the same can shaded three ways — flat (faceted corners), smooth-everywhere (the smeared AI bug: ribs melt, highlights warp at the rim), and by-angle (the contract: smooth walls, crisp edges) — under a strip light whose reflection exposes every normal discontinuity.</p>
+<ul><li><strong>The legacy shading API is gone — on both supported versions.</strong> <code>use_auto_smooth</code>, <code>use_custom_normals</code>, and <code>calc_normals</code> are AttributeError on 4.5 LTS <em>and</em> 5.1. AI-generated Blender code still emits <code>mesh.use_auto_smooth = True</code> constantly; any script carrying that habit dies immediately, and this check keeps it dead.</li><li><strong>Shade-by-angle is exact.</strong> <code>mesh.set_sharp_from_angle(30°)</code> (which also sets the face smooth flags — probed on both versions) marks sharp exactly the edges whose <em>independently recomputed</em> dihedral angle crosses the threshold: Shell 1144 of 4098 edges, Handle 32 of 368, Neck 128 of 272 (1304 of 4738) — an exact set match, not a count approximation.</li><li><strong>The evaluated shading matches the attribute&#x27;s promise.</strong> Through depsgraph evaluation, loop normals across a smooth edge are welded (deviation 0.0, tol 1e-3) and loop normals across a sharp edge are split by the dihedral (angle error 1.898e-03 rad, tol 5e-3 — the curved side band and the panels&#x27; rounded wall corners average a fan whose facets step at most 22.5 and 10 deg), all unit length (err 1.0e-07).</li><li><strong>Custom split normals survive depsgraph evaluation</strong> — with a quantization budget, not float precision: <code>normals_split_custom_set</code> stores per-loop normals in int16, so an 8196-loop round-trip reads back within <strong>3.904e-05</strong> (tol 2e-4), unit length within 1.7e-07. Asserting float-exact custom normals is a real bug this check catches. Each corner requests its face normal tilted 20 deg toward the corner bisector. The pattern matters: Blender&#x27;s lnor encoder merges requests within one fan that sit closer than ~0.81 deg and snaps an in-plane angle under 0.81 deg to zero. On this shell an index-swept pattern measured the merge (1.38e-02) and a 144-direction cycle hit the snap on 13 corners (9.1e-03). Neither is storage precision, so the check keeps clear of both.</li><li><strong>The divergence: the legacy <code>shade_auto_smooth</code> OPERATOR is a version-split trap.</strong> It builds the Smooth-by-Angle node-group modifier from a bundled asset. Headless on <strong>4.5 LTS the asset load never finishes</strong>: the op returns <code>{&#x27;CANCELLED&#x27;}</code> — no exception — and the mesh stays <strong>untouched</strong> (measured: 0 smooth faces, 0 modifiers). Any script that ignores the return set ships flat shading and never knows. On <strong>5.1</strong> it FINISHES and adds the <code>Smooth by Angle</code> NODES modifier. The portable path is the data API above, version-gated here explicitly.</li></ul>
+<p><strong>What each check catches on failure:</strong> author/audit threshold drift (probe: sharp marks applied at 20° but audited at 30°, exit 5, 48 extra edges on the shell); the two halves of the contract out of sync (probe: <code>sharp_edge</code> set but face smooth flags lost, exit 6, smooth-edge loops split by 3.902e-01); float-exactness assumed of custom normals (probe: tolerance 1e-6, exit 7, measured 3.904e-05); and any future version that resurrects the legacy API or changes the operator&#x27;s headless behavior (exit 3/8). The render path adds the Layer 1 gates: framing (exit 10) and asset quality (exit 11).</p>
+<p><strong>Version witness:</strong> every value above is identical on Blender 4.5.11 LTS, 5.1.2 and 5.2.1 LTS except the <code>shade_auto_smooth</code> operator behavior, which is asserted per version (CANCELLED + untouched on 4.5, FINISHED + NODES modifier on 5.1 and 5.2).</p>
+<p>The render shows three fresh builds of the same can, one per shading treatment. Left, flat: the side-band corners, cap and handle break into facets. Middle, smooth-everywhere (the shade-smooth-and-forget AI habit): the flat fields smear into gradients and the pressed panels go pillowy. Right, by-angle (the contract): crisp creases and smooth rounds, with the <code>sharp_edge</code> attribute read back from the mesh and traced as thin cyan lines, so the viewer sees exactly which edges the data marked hard. A low strip light makes the highlight shapes diverge between the three.</p>
 <h2>Run</h2>
 <pre><code># Cheap correctness check (no render) — the CI check:
 blender --background --python custom_normals_shade.py --
@@ -298,7 +298,7 @@ <h2>Run</h2>
 blender --background --python custom_normals_shade.py -- --output cans.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>Legacy shading API present, or modern path missing</td></tr><tr><td>4</td><td>Non-manifold edges (dihedral test undefined)</td></tr><tr><td>5</td><td>Sharp set ≠ independent dihedral (<code>--mismatch-angle</code> lands here)</td></tr><tr><td>6</td><td>Evaluated loop normals not welded/split as the sharp set promises</td></tr><tr><td>7</td><td>Custom split normals lost or dequantized in evaluation</td></tr><tr><td>8</td><td><code>shade_auto_smooth</code> operator behavior drifted from the version split</td></tr><tr><td>9</td><td><code>--output</code> produced no file</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>Legacy shading API present, or modern path missing</td></tr><tr><td>4</td><td>Non-manifold edges (dihedral test undefined)</td></tr><tr><td>5</td><td>Sharp set ≠ independent dihedral (<code>--mismatch-angle</code> lands here)</td></tr><tr><td>6</td><td>Evaluated loop normals not welded/split as the sharp set promises</td></tr><tr><td>7</td><td>Custom split normals lost or dequantized in evaluation</td></tr><tr><td>8</td><td><code>shade_auto_smooth</code> operator behavior drifted from the version split</td></tr><tr><td>9</td><td><code>--output</code> produced no file</td></tr><tr><td>10</td><td>Render path: Layer 1 framing violation (<code>gallery_framing</code>)</td></tr><tr><td>11</td><td>Render path: asset-quality floor violation (<code>gallery_asset_quality</code>)</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>--mismatch-angle</code>.</p>
     </section>
     <section class="detail-section src">
@@ -327,7 +327,9 @@ <h2>Source</h2>
                   carry their face normals (split by the dihedral)
   custom normals— per-loop normals set with `normals_split_custom_set`
                   survive depsgraph evaluation within the int16 storage
-                  quantization (~7.5e-05 measured, tol 2e-4), unit length
+                  quantization (3.9e-05 measured over 8196 loops, tol 2e-4),
+                  unit length; the request pattern stays clear of the
+                  encoder&#x27;s 0.81-deg merge/snap threshold (see that check)
   divergence    — the legacy `shade_auto_smooth` OPERATOR needs the bundled
                   Smooth-by-Angle node-group asset: headless on 4.5 LTS it
                   returns {&#x27;CANCELLED&#x27;} (&quot;Asset loading is unfinished&quot;) and
@@ -340,15 +342,25 @@ <h2>Source</h2>
 (``--same-axis`` in export-preset-axis).
 
 By default it runs only the correctness check (no render) — the CI smoke
-check. Pass --output to also render a still (the same can shaded flat /
-smooth-everywhere / by-angle, so a broken path reads as faceting or smear):
+check. Pass --output to also render a still: three fresh builds of the can
+shaded flat (faceted corners, cap and handle), smooth-everywhere (the flat
+fields smear, the pressed panels go pillowy) and by-angle (crisp creases,
+smooth rounds), with the by-angle can&#x27;s `sharp_edge` set read back from the
+mesh and traced as thin cyan lines. The render path is gated by
+gallery_framing (exit 10) and gallery_asset_quality (exit 11):
 
     blender --background --python custom_normals_shade.py --                 # check only
     blender --background --python custom_normals_shade.py -- --mismatch-angle
     blender --background --python custom_normals_shade.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 <span class="k">import</span> Matrix, Vector
+
+<span class="c"># Shared Layer 1 framing + asset-quality gates (render path only) — see</span>
+<span class="c"># gallery_framing.py for the import contract.</span>
+sys.path.insert(<span class="n">0</span>, os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir))
+<span class="k">import</span> gallery_framing  <span class="c"># noqa: E402</span>
+<span class="k">import</span> gallery_asset_quality  <span class="c"># noqa: E402</span>
 
 ANGLE_DEG = <span class="n">30.0</span>          <span class="c"># shade-by-angle threshold</span>
 ANGLE = math.radians(ANGLE_DEG)
@@ -356,15 +368,42 @@ <h2>Source</h2>
 TOL_UNIT = <span class="n">1e-6</span>           <span class="c"># unit-length tolerance for evaluated normals (measured 4.5e-08)</span>
 TOL_SMOOTH = <span class="n">1e-3</span>         <span class="c"># loop-normal equality across a welded (smooth) edge</span>
 TOL_SHARP = <span class="n">5e-3</span>          <span class="c"># radians: split-normal angle vs dihedral across a sharp edge</span>
+CUSTOM_TILT = math.radians(<span class="n">20.0</span>)  <span class="c"># custom-normal round-trip request (see that check)</span>
 
 <span class="c"># ---------------------------------------------------------------------------</span>
-<span class="c"># Prop construction. A 20-unit jerry can: rounded-slab shell, pressed X ribs</span>
-<span class="c"># floating on both faces, spout neck + cap, three-post carry handle. All</span>
-<span class="c"># dimensions invented for this prop; ribs are floater prisms, the game-prop</span>
-<span class="c"># norm — every checked mesh is itself closed and manifold.</span>
+<span class="c"># Prop construction. A 20-litre-style jerry can in scene units: a pressed</span>
+<span class="c"># steel shell (rounded side band, X-stamped front and back faces: four</span>
+<span class="c"># raised rounded-triangle panels with 45-degree walls, the X is the channel</span>
+<span class="c"># between them), a weld-seam bead round the band, a triple carry handle on</span>
+<span class="c"># welded feet, and a spout with red seal, cap, cam lever, hinge and locking</span>
+<span class="c"># pin. Every part is its own closed manifold mesh (the game-prop norm), and</span>
+<span class="c"># the facet angles are chosen for the by-angle contract: curved surfaces</span>
+<span class="c"># step at &lt;= 22.5 deg (smooth under the 30 deg threshold), pressed creases</span>
+<span class="c"># break at 45 or 90 deg (sharp), nothing sits near 30.</span>
+<span class="c">#</span>
+<span class="c"># A `wear` POINT attribute (1 on exposed convex edges, 0 a support ring</span>
+<span class="c"># away) drives the paint-chip mask in the material; support rings are</span>
+<span class="c"># coplanar, so they add no shading break and no dihedral.</span>
 <span class="c"># ---------------------------------------------------------------------------</span>
 
-SHELL_W, SHELL_H, SHELL_D, SHELL_R = <span class="n">1.4</span>, <span class="n">1.8</span>, <span class="n">0.62</span>, <span class="n">0.28</span>
+W, H, D = <span class="n">1.30</span>, <span class="n">1.80</span>, <span class="n">0.62</span>      <span class="c"># shell width (X), height (Z), depth (Y)</span>
+R = <span class="n">0.24</span>                        <span class="c"># front-view corner radius of the side band</span>
+CORNER_SEGS = <span class="n">4</span>                 <span class="c"># 22.5 deg facets: smooth under the threshold</span>
+EDGE_BAND = <span class="n">0.07</span>                <span class="c"># side-band wear ring distance from each face</span>
+FACE_BORDER = <span class="n">0.04</span>              <span class="c"># flat border inside the face outline</span>
+PANEL_MARGIN = <span class="n">0.015</span>
+CHANNEL = <span class="n">0.045</span>                 <span class="c"># half-width of the X channel between panels</span>
+PANEL_R = <span class="n">0.09</span>                  <span class="c"># panel base corner radius</span>
+PRESS_H = <span class="n">0.04</span>                  <span class="c"># panel height; 45 deg walls (run == rise)</span>
+ARC_STEP = <span class="n">10.0</span>                 <span class="c"># max degrees per panel-corner facet</span>
+FIELD_STEP = <span class="n">0.08</span>               <span class="c"># max straight-run edge length (fill quality)</span>
+WEAR = <span class="s">&quot;wear&quot;</span>
+
+HANDLE_Y = <span class="n">0.10</span>
+HANDLE_X = (-<span class="n">0.50</span>, -<span class="n">0.22</span>, <span class="n">0.06</span>)  <span class="c"># left leg, centre post, right leg</span>
+HANDLE_TOP = H + <span class="n">0.26</span>
+SPOUT_AT = (<span class="n">0.27</span>, -<span class="n">0.07</span>)
+SPOUT_TILT = <span class="n">12.0</span>               <span class="c"># degrees, leaning out over the corner</span>
 
 
 <span class="k">def</span> signed_volume(me):
@@ -378,9 +417,11 @@ <h2>Source</h2>
     <span class="k">return</span> vol
 
 
-<span class="k">def</span> finish_mesh(name, bm):
+<span class="k">def</span> finish_mesh(name, bm, matrix=<span class="k">None</span>):
     me = bpy.data.meshes.new(name)
     <span class="k">try</span>:
+        <span class="k">if</span> matrix <span class="k">is</span> <span class="k">not</span> <span class="k">None</span>:
+            bmesh.ops.transform(bm, matrix=matrix, verts=bm.verts)
         bmesh.ops.recalc_face_normals(bm, faces=bm.faces)
         bm.to_mesh(me)
     <span class="k">finally</span>:
@@ -393,119 +434,300 @@ <h2>Source</h2>
     <span class="k">return</span> obj
 
 
-<span class="k">def</span> rounded_rect_profile(w, h, r, segs):
-    <span class="s">&quot;&quot;&quot;(x, z) loop of a rounded rectangle, z from 0 to h, CCW seen from -Y.&quot;&quot;&quot;</span>
+<span class="k">def</span> rrect(inset, segs=CORNER_SEGS):
+    <span class="s">&quot;&quot;&quot;(x, z) loop of the shell&#x27;s front-view rounded rectangle, inset by
+    `inset`, CCW in (x, z). Corners include both arc ends, so the straight
+    runs between them are exactly axis-aligned; the runs are split every
+    ~FIELD_STEP so the pressed-face fill triangulates without slivers.&quot;&quot;&quot;</span>
+    rr = R - inset
+    cx = W / <span class="n">2</span> - R
+    corners = ((cx, R, -<span class="n">90</span>), (cx, H - R, <span class="n">0</span>), (-cx, H - R, <span class="n">90</span>), (-cx, R, <span class="n">180</span>))
     pts = []
-    <span class="k">for</span> cx, cz, a0 <span class="k">in</span> ((w / <span class="n">2</span> - r, r, -<span class="n">90</span>), (w / <span class="n">2</span> - r, h - r, <span class="n">0</span>),
-                       (-(w / <span class="n">2</span> - r), h - r, <span class="n">90</span>), (-(w / <span class="n">2</span> - r), r, <span class="n">180</span>)):
-        <span class="k">for</span> i <span class="k">in</span> range(segs):
+    <span class="k">for</span> k, (ccx, ccz, a0) <span class="k">in</span> enumerate(corners):
+        <span class="k">for</span> i <span class="k">in</span> range(segs + <span class="n">1</span>):
             a = math.radians(a0 + <span class="n">90.0</span> * i / segs)
-            pts.append((cx + r * math.cos(a), cz + r * math.sin(a)))
+            pts.append((ccx + rr * math.cos(a), ccz + rr * math.sin(a)))
+        nx, nz, b0 = corners[(k + <span class="n">1</span>) % <span class="n">4</span>]
+        q = (nx + rr * math.cos(math.radians(b0)), nz + rr * math.sin(math.radians(b0)))
+        p0 = pts[-<span class="n">1</span>]
+        cuts = max(<span class="n">1</span>, math.ceil(math.hypot(q[<span class="n">0</span>] - p0[<span class="n">0</span>], q[<span class="n">1</span>] - p0[<span class="n">1</span>]) / FIELD_STEP))
+        pts.extend((p0[<span class="n">0</span>] + (q[<span class="n">0</span>] - p0[<span class="n">0</span>]) * t / cuts, p0[<span class="n">1</span>] + (q[<span class="n">1</span>] - p0[<span class="n">1</span>]) * t / cuts)
+                   <span class="k">for</span> t <span class="k">in</span> range(<span class="n">1</span>, cuts))
     <span class="k">return</span> pts
 
 
-<span class="k">def</span> build_shell():
-    <span class="s">&quot;&quot;&quot;Loft the rounded-rect profile along Y; caps are the end ngons.&quot;&quot;&quot;</span>
-    prof = rounded_rect_profile(SHELL_W, SHELL_H, SHELL_R, <span class="n">6</span>)
-    n = len(prof)
-    y0, y1 = -SHELL_D / <span class="n">2</span>, SHELL_D / <span class="n">2</span>
-    bm = bmesh.new()
-    front = [bm.verts.new((x, y0, z)) <span class="k">for</span> x, z <span class="k">in</span> prof]
-    back = [bm.verts.new((x, y1, z)) <span class="k">for</span> x, z <span class="k">in</span> prof]
+<span class="k">def</span> _ccw(poly):
+    area = sum(poly[i][<span class="n">0</span>] * poly[(i + <span class="n">1</span>) % len(poly)][<span class="n">1</span>]
+               - poly[(i + <span class="n">1</span>) % len(poly)][<span class="n">0</span>] * poly[i][<span class="n">1</span>] <span class="k">for</span> i <span class="k">in</span> range(len(poly)))
+    <span class="k">return</span> poly <span class="k">if</span> area &gt; <span class="n">0</span> <span class="k">else</span> poly[::-<span class="n">1</span>]
+
+
+<span class="k">def</span> _inset_poly(poly, d):
+    <span class="s">&quot;&quot;&quot;Convex CCW polygon with every edge moved inward by d.&quot;&quot;&quot;</span>
+    n = len(poly)
+    lines = []
+    <span class="k">for</span> i <span class="k">in</span> range(n):
+        p, q = Vector(poly[i]), Vector(poly[(i + <span class="n">1</span>) % n])
+        t = (q - p).normalized()
+        lines.append((p + Vector((-t.y, t.x)) * d, t))
+    out = []
+    <span class="k">for</span> i <span class="k">in</span> range(n):
+        (p1, t1), (p2, t2) = lines[i - <span class="n">1</span>], lines[i]
+        den = t1.x * t2.y - t1.y * t2.x
+        s = ((p2.x - p1.x) * t2.y - (p2.y - p1.y) * t2.x) / den
+        out.append(p1 + t1 * s)
+    <span class="k">return</span> out
+
+
+<span class="k">def</span> rounded_outline(tri, off, r):
+    <span class="s">&quot;&quot;&quot;Arc samples [(core point, angle)] of a convex polygon inset by `off`
+    with its corners rounded to radius r. Sampling a smaller radius with
+    the same list gives a concentric outline (a 45-deg wall or a flat ring
+    between them).&quot;&quot;&quot;</span>
+    core = _inset_poly(_ccw(tri), off + r)
+    n = len(core)
+    samples = []
+    <span class="k">for</span> i <span class="k">in</span> range(n):
+        t_in = (core[i] - core[i - <span class="n">1</span>]).normalized()
+        t_out = (core[(i + <span class="n">1</span>) % n] - core[i]).normalized()
+        a0 = math.atan2(-t_in.x, t_in.y)          <span class="c"># outward normal, incoming edge</span>
+        a1 = math.atan2(-t_out.x, t_out.y)        <span class="c"># outward normal, outgoing edge</span>
+        sweep = (a1 - a0) % (<span class="n">2.0</span> * math.pi)
+        k = max(<span class="n">1</span>, math.ceil(math.degrees(sweep) / ARC_STEP))
+        samples.extend((core[i], a0 + sweep * j / k) <span class="k">for</span> j <span class="k">in</span> range(k + <span class="n">1</span>))
+        run = core[(i + <span class="n">1</span>) % n] - core[i]
+        cuts = max(<span class="n">1</span>, math.ceil(run.length / FIELD_STEP))
+        samples.extend((core[i] + run * (t / cuts), a1) <span class="k">for</span> t <span class="k">in</span> range(<span class="n">1</span>, cuts))
+    <span class="k">return</span> samples
+
+
+<span class="k">def</span> panel_triangles():
+    <span class="s">&quot;&quot;&quot;The four stamped panels; the X is what is left between them.&quot;&quot;&quot;</span>
+    a = W / <span class="n">2</span> - FACE_BORDER - PANEL_MARGIN
+    zt, zb, zc = H - FACE_BORDER - PANEL_MARGIN, FACE_BORDER + PANEL_MARGIN, H / <span class="n">2</span>
+    <span class="k">return</span> [((-a, zt), (<span class="n">0.0</span>, zc), (a, zt)), ((-a, zb), (a, zb), (<span class="n">0.0</span>, zc)),
+            ((-a, zt), (-a, zb), (<span class="n">0.0</span>, zc)), ((a, zb), (a, zt), (<span class="n">0.0</span>, zc))]
+
+
+<span class="k">def</span> pressed_face(bm, wl, outline, y0, s):
+    <span class="s">&quot;&quot;&quot;Front (s=-1) or back (s=+1) face: flat border ring, four raised
+    panels, and a triangle fill of the flat field between them.&quot;&quot;&quot;</span>
+    inner = [bm.verts.new((x, y0, z)) <span class="k">for</span> x, z <span class="k">in</span> rrect(FACE_BORDER)]
+    n = len(inner)
     <span class="k">for</span> i <span class="k">in</span> range(n):
         j = (i + <span class="n">1</span>) % n
-        bm.faces.new((front[i], back[i], back[j], front[j]))
-    bm.faces.new(front)
-    bm.faces.new(back)
-    <span class="k">return</span> finish_mesh(<span class="s">&quot;Shell&quot;</span>, bm)
-
-
-<span class="k">def</span> build_rib(name, p0, p1, face_y, outward):
-    <span class="s">&quot;&quot;&quot;Trapezoid-section pressed rib from p0 to p1 (x, z), raised off the
-    face plane by `outward` (-1 front, +1 back).&quot;&quot;&quot;</span>
-    wb, wt, hgt = <span class="n">0.09</span>, <span class="n">0.06</span>, <span class="n">0.045</span>
-    d = Vector((p1[<span class="n">0</span>] - p0[<span class="n">0</span>], <span class="n">0.0</span>, p1[<span class="n">1</span>] - p0[<span class="n">1</span>])).normalized()
-    side = Vector((-d.z, <span class="n">0.0</span>, d.x))
-    up = Vector((<span class="n">0.0</span>, outward, <span class="n">0.0</span>))
+        bm.faces.new((outline[i], outline[j], inner[j], inner[i]))
+    fill = [bm.edges.get((inner[i], inner[(i + <span class="n">1</span>) % n])) <span class="k">for</span> i <span class="k">in</span> range(n)]
+    <span class="k">for</span> tri <span class="k">in</span> panel_triangles():
+        samples = rounded_outline(tri, CHANNEL, PANEL_R)
+
+        <span class="k">def</span> ring(r, lift, wear):
+            vs = []
+            <span class="k">for</span> c, a <span class="k">in</span> samples:
+                v = bm.verts.new((c.x + r * math.cos(a), y0 + s * lift, c.y + r * math.sin(a)))
+                v[wl] = wear
+                vs.append(v)
+            <span class="k">return</span> vs
+        base = ring(PANEL_R, <span class="n">0.0</span>, <span class="n">0.15</span>)
+        top = ring(PANEL_R - PRESS_H, PRESS_H, <span class="n">1.0</span>)
+        top_in = ring(PANEL_R - PRESS_H - <span class="n">0.022</span>, PRESS_H, <span class="n">0.0</span>)
+        m = len(base)
+        <span class="k">for</span> i <span class="k">in</span> range(m):
+            j = (i + <span class="n">1</span>) % m
+            bm.faces.new((base[i], base[j], top[j], top[i]))
+            bm.faces.new((top[i], top[j], top_in[j], top_in[i]))
+        bm.faces.new(top_in)
+        fill += [bm.edges.get((base[i], base[(i + <span class="n">1</span>) % m])) <span class="k">for</span> i <span class="k">in</span> range(m)]
+    bmesh.ops.triangle_fill(bm, use_beauty=<span class="k">True</span>, use_dissolve=<span class="k">False</span>,
+                            edges=fill, normal=(<span class="n">0.0</span>, s, <span class="n">0.0</span>))
+
+
+<span class="k">def</span> build_shell(name):
+    <span class="s">&quot;&quot;&quot;Side band lofted along Y through wear-ring stations, capped by the
+    two pressed faces. The face/band edge is a true 90-deg break.&quot;&quot;&quot;</span>
     bm = bmesh.new()
-    ends = []
-    <span class="k">for</span> px, pz <span class="k">in</span> (p0, p1):
-        c = Vector((px, face_y, pz))
-        ends.append([bm.verts.new(c - side * wb), bm.verts.new(c + side * wb),
-                     bm.verts.new(c + side * wt + up * hgt),
-                     bm.verts.new(c - side * wt + up * hgt)])
-    a, b = ends
-    bm.faces.new((a[<span class="n">0</span>], a[<span class="n">1</span>], a[<span class="n">2</span>], a[<span class="n">3</span>]))
-    bm.faces.new((b[<span class="n">1</span>], b[<span class="n">0</span>], b[<span class="n">3</span>], b[<span class="n">2</span>]))
-    bm.faces.new((a[<span class="n">1</span>], b[<span class="n">1</span>], b[<span class="n">2</span>], a[<span class="n">2</span>]))
-    bm.faces.new((a[<span class="n">3</span>], b[<span class="n">3</span>], b[<span class="n">0</span>], a[<span class="n">0</span>]))
-    bm.faces.new((a[<span class="n">0</span>], b[<span class="n">0</span>], b[<span class="n">1</span>], a[<span class="n">1</span>]))
-    bm.faces.new((a[<span class="n">2</span>], b[<span class="n">2</span>], b[<span class="n">3</span>], a[<span class="n">3</span>]))
+    wl = bm.verts.layers.float.new(WEAR)
+    prof = rrect(<span class="n">0.0</span>)
+    n = len(prof)
+    rings = []
+    <span class="k">for</span> y, wear <span class="k">in</span> ((-D / <span class="n">2</span>, <span class="n">1.0</span>), (-D / <span class="n">2</span> + EDGE_BAND, <span class="n">0.0</span>), (<span class="n">0.0</span>, <span class="n">0.0</span>),
+                    (D / <span class="n">2</span> - EDGE_BAND, <span class="n">0.0</span>), (D / <span class="n">2</span>, <span class="n">1.0</span>)):
+        ring = [bm.verts.new((x, y, z)) <span class="k">for</span> x, z <span class="k">in</span> prof]
+        <span class="k">for</span> v <span class="k">in</span> ring:
+            v[wl] = wear
+        rings.append(ring)
+    <span class="k">for</span> ra, rb <span class="k">in</span> zip(rings, rings[<span class="n">1</span>:]):
+        <span class="k">for</span> i <span class="k">in</span> range(n):
+            j = (i + <span class="n">1</span>) % n
+            bm.faces.new((ra[i], ra[j], rb[j], rb[i]))
+    pressed_face(bm, wl, rings[<span class="n">0</span>], -D / <span class="n">2</span>, -<span class="n">1.0</span>)
+    pressed_face(bm, wl, rings[-<span class="n">1</span>], D / <span class="n">2</span>, <span class="n">1.0</span>)
     <span class="k">return</span> finish_mesh(name, bm)
 
 
-<span class="k">def</span> lathe(name, profile, segments):
-    <span class="s">&quot;&quot;&quot;Spin an (r, z) profile around Z; r == 0 ends become poles.&quot;&quot;&quot;</span>
+<span class="k">def</span> sweep(name, path, section, axis, closed=<span class="k">False</span>, wear=<span class="n">0.0</span>, matrix=<span class="k">None</span>):
+    <span class="s">&quot;&quot;&quot;Sweep a closed 2D section (u along the in-plane normal, v along
+    `axis`) down a path lying in the plane normal to `axis`. Open paths are
+    capped with ngons.&quot;&quot;&quot;</span>
+    axis = Vector(axis)
+    pts = [Vector(p) <span class="k">for</span> p <span class="k">in</span> path]
+    n = len(pts)
     bm = bmesh.new()
+    wl = bm.verts.layers.float.new(WEAR)
+    rings = []
+    <span class="k">for</span> i, p <span class="k">in</span> enumerate(pts):
+        <span class="k">if</span> closed:
+            t = (pts[(i + <span class="n">1</span>) % n] - pts[i - <span class="n">1</span>])
+        <span class="k">else</span>:
+            t = pts[min(i + <span class="n">1</span>, n - <span class="n">1</span>)] - pts[max(i - <span class="n">1</span>, <span class="n">0</span>)]
+        nrm = axis.cross(t.normalized()).normalized()   <span class="c"># outward for CCW paths</span>
+        ring = [bm.verts.new(p + nrm * u + axis * v) <span class="k">for</span> u, v <span class="k">in</span> section]
+        <span class="k">for</span> v <span class="k">in</span> ring:
+            v[wl] = wear
+        rings.append(ring)
+    k = len(section)
+    <span class="k">for</span> i <span class="k">in</span> range(n <span class="k">if</span> closed <span class="k">else</span> n - <span class="n">1</span>):
+        ra, rb = rings[i], rings[(i + <span class="n">1</span>) % n]
+        <span class="k">for</span> j <span class="k">in</span> range(k):
+            jj = (j + <span class="n">1</span>) % k
+            bm.faces.new((ra[j], ra[jj], rb[jj], rb[j]))
+    <span class="k">if</span> <span class="k">not</span> closed:
+        bm.faces.new(rings[<span class="n">0</span>])
+        bm.faces.new(rings[-<span class="n">1</span>][::-<span class="n">1</span>])
+    <span class="k">return</span> finish_mesh(name, bm, matrix)
+
+
+<span class="k">def</span> circle(r, segs=<span class="n">16</span>):
+    <span class="k">return</span> [(r * math.cos(<span class="n">2</span> * math.pi * i / segs), r * math.sin(<span class="n">2</span> * math.pi * i / segs))
+            <span class="k">for</span> i <span class="k">in</span> range(segs)]
+
+
+<span class="k">def</span> lathe(name, profile, segments=<span class="n">16</span>, closed=<span class="k">False</span>, wear=<span class="k">None</span>, matrix=<span class="k">None</span>):
+    <span class="s">&quot;&quot;&quot;Spin an (r, z) profile around Z; r == 0 ends become poles, a closed
+    profile makes a ring. `wear` is an optional per-profile-point list.&quot;&quot;&quot;</span>
+    wear = list(wear) <span class="k">if</span> wear <span class="k">else</span> [<span class="n">0.0</span>] * len(profile)
+    bm = bmesh.new()
+    wl = bm.verts.layers.float.new(WEAR)
     bot = top = <span class="k">None</span>
-    <span class="k">if</span> profile[<span class="n">0</span>][<span class="n">0</span>] == <span class="n">0.0</span>:
+    <span class="k">if</span> <span class="k">not</span> closed <span class="k">and</span> profile[<span class="n">0</span>][<span class="n">0</span>] == <span class="n">0.0</span>:
         bot = bm.verts.new((<span class="n">0.0</span>, <span class="n">0.0</span>, profile[<span class="n">0</span>][<span class="n">1</span>]))
-        profile = profile[<span class="n">1</span>:]
-    <span class="k">if</span> profile[-<span class="n">1</span>][<span class="n">0</span>] == <span class="n">0.0</span>:
+        profile, wear = profile[<span class="n">1</span>:], wear[<span class="n">1</span>:]
+    <span class="k">if</span> <span class="k">not</span> closed <span class="k">and</span> profile[-<span class="n">1</span>][<span class="n">0</span>] == <span class="n">0.0</span>:
         top = bm.verts.new((<span class="n">0.0</span>, <span class="n">0.0</span>, profile[-<span class="n">1</span>][<span class="n">1</span>]))
-        profile = profile[:-<span class="n">1</span>]
+        profile, wear = profile[:-<span class="n">1</span>], wear[:-<span class="n">1</span>]
     rings = []
     <span class="k">for</span> i <span class="k">in</span> range(segments):
         a = <span class="n">2.0</span> * math.pi * i / segments
-        rings.append([bm.verts.new((r * math.cos(a), r * math.sin(a), z))
-                      <span class="k">for</span> r, z <span class="k">in</span> profile])
+        ring = [bm.verts.new((r * math.cos(a), r * math.sin(a), z)) <span class="k">for</span> r, z <span class="k">in</span> profile]
+        <span class="k">for</span> v, w <span class="k">in</span> zip(ring, wear):
+            v[wl] = w
+        rings.append(ring)
+    m = len(profile)
     <span class="k">for</span> i <span class="k">in</span> range(segments):
         j = (i + <span class="n">1</span>) % segments
-        <span class="k">for</span> k <span class="k">in</span> range(len(profile) - <span class="n">1</span>):
-            bm.faces.new((rings[i][k], rings[j][k], rings[j][k + <span class="n">1</span>], rings[i][k + <span class="n">1</span>]))
+        <span class="k">for</span> k <span class="k">in</span> range(m <span class="k">if</span> closed <span class="k">else</span> m - <span class="n">1</span>):
+            kk = (k + <span class="n">1</span>) % m
+            bm.faces.new((rings[i][k], rings[j][k], rings[j][kk], rings[i][kk]))
         <span class="k">if</span> bot <span class="k">is</span> <span class="k">not</span> <span class="k">None</span>:
             bm.faces.new((rings[j][<span class="n">0</span>], rings[i][<span class="n">0</span>], bot))
         <span class="k">if</span> top <span class="k">is</span> <span class="k">not</span> <span class="k">None</span>:
             bm.faces.new((rings[i][-<span class="n">1</span>], rings[j][-<span class="n">1</span>], top))
-    <span class="k">return</span> finish_mesh(name, bm)
+    <span class="k">return</span> finish_mesh(name, bm, matrix)
+
+
+<span class="k">def</span> extrude_profile(name, poly, thickness, bevel, matrix=<span class="k">None</span>, wear=<span class="n">0.6</span>):
+    <span class="s">&quot;&quot;&quot;A flat plate from an (x, z) outline, thickness along Y, every edge
+    chamfered — the cam lever.&quot;&quot;&quot;</span>
+    bm = bmesh.new()
+    wl = bm.verts.layers.float.new(WEAR)
+    <span class="k">try</span>:
+        front = [bm.verts.new((x, -thickness / <span class="n">2</span>, z)) <span class="k">for</span> x, z <span class="k">in</span> poly]
+        back = [bm.verts.new((x, thickness / <span class="n">2</span>, z)) <span class="k">for</span> x, z <span class="k">in</span> poly]
+        n = len(poly)
+        <span class="k">for</span> i <span class="k">in</span> range(n):
+            j = (i + <span class="n">1</span>) % n
+            bm.faces.new((front[i], front[j], back[j], back[i]))
+        bm.faces.new(front)
+        bm.faces.new(back[::-<span class="n">1</span>])
+        bmesh.ops.recalc_face_normals(bm, faces=bm.faces)
+        bmesh.ops.bevel(bm, geom=list(bm.edges), offset=bevel, segments=<span class="n">1</span>,
+                        affect=<span class="s">&#x27;EDGES&#x27;</span>, clamp_overlap=<span class="k">True</span>)
+        <span class="k">for</span> v <span class="k">in</span> bm.verts:
+            v[wl] = wear
+    <span class="k">except</span> Exception:
+        bm.free()
+        <span class="k">raise</span>
+    <span class="k">return</span> finish_mesh(name, bm, matrix)
+
+
+<span class="k">def</span> arc(cx, cz, r, a0, a1, steps):
+    <span class="k">return</span> [(cx + r * math.cos(math.radians(a0 + (a1 - a0) * i / steps)),
+             cz + r * math.sin(math.radians(a0 + (a1 - a0) * i / steps)))
+            <span class="k">for</span> i <span class="k">in</span> range(steps + <span class="n">1</span>)]
 
 
-<span class="k">def</span> build_jerry_can():
-    <span class="s">&quot;&quot;&quot;All parts at world placement; returns {&quot;shell&quot;, &quot;rib&quot;, &quot;neck&quot;, &quot;parts&quot;}.&quot;&quot;&quot;</span>
-    shell = build_shell()
+<span class="k">def</span> build_jerry_can(suffix=<span class="s">&quot;&quot;</span>):
+    <span class="s">&quot;&quot;&quot;All parts at world placement; returns {&quot;shell&quot;, &quot;handle&quot;, &quot;neck&quot;, &quot;parts&quot;}.&quot;&quot;&quot;</span>
+    <span class="k">def</span> nm(base):
+        <span class="k">return</span> base + suffix
+
+    shell = build_shell(nm(<span class="s">&quot;Shell&quot;</span>))
     parts = [shell]
 
-    ribs = []
-    inset = [(<span class="n">0.46</span>, <span class="n">0.22</span>), (<span class="n">0.46</span>, <span class="n">1.58</span>)]
-    specs = [((inset[<span class="n">0</span>], ( -inset[<span class="n">0</span>][<span class="n">0</span>], inset[<span class="n">1</span>][<span class="n">1</span>])), <span class="s">&quot;RibDiagA&quot;</span>),
-             (((-inset[<span class="n">0</span>][<span class="n">0</span>], inset[<span class="n">0</span>][<span class="n">1</span>]), inset[<span class="n">1</span>]), <span class="s">&quot;RibDiagB&quot;</span>),
-             (((<span class="n">0.0</span>, <span class="n">0.18</span>), (<span class="n">0.0</span>, <span class="n">1.62</span>)), <span class="s">&quot;RibVert&quot;</span>)]
-    <span class="k">for</span> fy, out, tag <span class="k">in</span> ((-SHELL_D / <span class="n">2</span>, -<span class="n">1.0</span>, <span class="s">&quot;F&quot;</span>), (SHELL_D / <span class="n">2</span>, <span class="n">1.0</span>, <span class="s">&quot;B&quot;</span>)):
-        <span class="k">for</span> (p0, p1), rn <span class="k">in</span> specs:
-            ribs.append(build_rib(<span class="s">f&quot;</span>{rn}{tag}<span class="s">&quot;</span>, p0, p1, fy, out))
-    parts.extend(ribs)
-
-    neck = lathe(<span class="s">&quot;Neck&quot;</span>, [(<span class="n">0.0</span>, <span class="n">0.0</span>), (<span class="n">0.21</span>, <span class="n">0.0</span>), (<span class="n">0.21</span>, <span class="n">0.05</span>), (<span class="n">0.175</span>, <span class="n">0.07</span>),
-                          (<span class="n">0.165</span>, <span class="n">0.10</span>), (<span class="n">0.165</span>, <span class="n">0.16</span>), (<span class="n">0.185</span>, <span class="n">0.17</span>),
-                          (<span class="n">0.185</span>, <span class="n">0.20</span>), (<span class="n">0.165</span>, <span class="n">0.21</span>), (<span class="n">0.165</span>, <span class="n">0.24</span>), (<span class="n">0.0</span>, <span class="n">0.24</span>)], <span class="n">16</span>)
-    neck.location = (<span class="n">0.42</span>, -<span class="n">0.12</span>, <span class="n">1.75</span>)
-    neck.rotation_euler = (math.radians(-<span class="n">8.0</span>), <span class="n">0.0</span>, <span class="n">0.0</span>)
-    cap = lathe(<span class="s">&quot;Cap&quot;</span>, [(<span class="n">0.0</span>, <span class="n">0.0</span>), (<span class="n">0.205</span>, <span class="n">0.0</span>), (<span class="n">0.205</span>, <span class="n">0.04</span>), (<span class="n">0.19</span>, <span class="n">0.05</span>),
-                        (<span class="n">0.19</span>, <span class="n">0.11</span>), (<span class="n">0.14</span>, <span class="n">0.14</span>), (<span class="n">0.0</span>, <span class="n">0.145</span>)], <span class="n">16</span>)
-    cap.location = (<span class="n">0.42</span>, -<span class="n">0.0866</span>, <span class="n">1.9877</span>)
-    cap.rotation_euler = (math.radians(-<span class="n">8.0</span>), <span class="n">0.0</span>, <span class="n">0.0</span>)
-    parts.extend((neck, cap))
-
-    <span class="k">for</span> i, x <span class="k">in</span> enumerate((-<span class="n">0.28</span>, <span class="n">0.0</span>, <span class="n">0.28</span>)):
-        post = lathe(<span class="s">f&quot;</span><span class="s">Post</span>{i}<span class="s">&quot;</span>, [(<span class="n">0.0</span>, <span class="n">0.0</span>), (<span class="n">0.055</span>, <span class="n">0.0</span>), (<span class="n">0.055</span>, <span class="n">0.17</span>), (<span class="n">0.0</span>, <span class="n">0.17</span>)], <span class="n">16</span>)
-        post.location = (x, <span class="n">0.08</span>, <span class="n">1.79</span>)
-        parts.append(post)
-    grip = lathe(<span class="s">&quot;Grip&quot;</span>, [(<span class="n">0.0</span>, <span class="n">0.0</span>), (<span class="n">0.06</span>, <span class="n">0.0</span>), (<span class="n">0.06</span>, <span class="n">0.68</span>), (<span class="n">0.0</span>, <span class="n">0.68</span>)], <span class="n">16</span>)
-    grip.rotation_euler = (<span class="n">0.0</span>, math.radians(<span class="n">90.0</span>), <span class="n">0.0</span>)
-    grip.location = (-<span class="n">0.34</span>, <span class="n">0.08</span>, <span class="n">1.96</span>)
-    parts.append(grip)
-
-    <span class="k">return</span> {<span class="s">&quot;shell&quot;</span>: shell, <span class="s">&quot;rib&quot;</span>: ribs[<span class="n">0</span>], <span class="s">&quot;neck&quot;</span>: neck, <span class="s">&quot;parts&quot;</span>: parts}
+    <span class="c"># weld seam: a chamfered bead swept round the side band at mid-depth</span>
+    bead = [(-<span class="n">0.012</span>, -<span class="n">0.028</span>), (<span class="n">0.010</span>, -<span class="n">0.028</span>), (<span class="n">0.021</span>, -<span class="n">0.012</span>),
+            (<span class="n">0.021</span>, <span class="n">0.012</span>), (<span class="n">0.010</span>, <span class="n">0.028</span>), (-<span class="n">0.012</span>, <span class="n">0.028</span>)]
+    seam_path = [(x, <span class="n">0.0</span>, z) <span class="k">for</span> x, z <span class="k">in</span> rrect(<span class="n">0.0</span>)]
+    parts.append(sweep(nm(<span class="s">&quot;WeldSeam&quot;</span>), seam_path, bead, (<span class="n">0.0</span>, <span class="n">1.0</span>, <span class="n">0.0</span>),
+                       closed=<span class="k">True</span>, wear=<span class="n">0.7</span>))
+
+    <span class="c"># triple carry handle: one bent tube over two legs, a centre post, and</span>
+    <span class="c"># three welded feet on the shell top</span>
+    x0, xm, x1 = HANDLE_X
+    rb, zb = <span class="n">0.09</span>, H - <span class="n">0.03</span>
+    hp = ([(x0, zb), (x0, HANDLE_TOP - rb)]
+          + arc(x0 + rb, HANDLE_TOP - rb, rb, <span class="n">180</span>, <span class="n">90</span>, <span class="n">4</span>)[<span class="n">1</span>:]
+          + arc(x1 - rb, HANDLE_TOP - rb, rb, <span class="n">90</span>, <span class="n">0</span>, <span class="n">4</span>) + [(x1, zb)])
+    handle = sweep(nm(<span class="s">&quot;Handle&quot;</span>), [(x, HANDLE_Y, z) <span class="k">for</span> x, z <span class="k">in</span> hp], circle(<span class="n">0.042</span>),
+                   (<span class="n">0.0</span>, <span class="n">1.0</span>, <span class="n">0.0</span>), wear=<span class="n">0.45</span>)
+    parts.append(handle)
+    parts.append(sweep(nm(<span class="s">&quot;HandlePost&quot;</span>), [(xm, HANDLE_Y, zb), (xm, HANDLE_Y, HANDLE_TOP)],
+                       circle(<span class="n">0.036</span>), (<span class="n">0.0</span>, <span class="n">1.0</span>, <span class="n">0.0</span>), wear=<span class="n">0.3</span>))
+    foot = [(<span class="n">0.0</span>, -<span class="n">0.02</span>), (<span class="n">0.085</span>, -<span class="n">0.02</span>), (<span class="n">0.085</span>, <span class="n">0.006</span>), (<span class="n">0.066</span>, <span class="n">0.025</span>), (<span class="n">0.0</span>, <span class="n">0.025</span>)]
+    <span class="k">for</span> i, x <span class="k">in</span> enumerate(HANDLE_X):
+        parts.append(lathe(nm(<span class="s">f&quot;</span><span class="s">HandleFoot</span>{i}<span class="s">&quot;</span>), foot, <span class="n">16</span>, wear=(<span class="n">0</span>, <span class="n">0</span>, <span class="n">1</span>, <span class="n">0.6</span>, <span class="n">0</span>),
+                           matrix=Matrix.Translation((x, HANDLE_Y, H))))
+
+    <span class="c"># spout assembly, built on a local +Z axis and tilted out over the corner</span>
+    sm = (Matrix.Translation((SPOUT_AT[<span class="n">0</span>], SPOUT_AT[<span class="n">1</span>], H))
+          @ Matrix.Rotation(math.radians(SPOUT_TILT), <span class="n">4</span>, <span class="s">&#x27;Y&#x27;</span>))
+    neck = lathe(nm(<span class="s">&quot;Neck&quot;</span>), [(<span class="n">0.0</span>, -<span class="n">0.06</span>), (<span class="n">0.19</span>, -<span class="n">0.06</span>), (<span class="n">0.19</span>, <span class="n">0.02</span>), (<span class="n">0.15</span>, <span class="n">0.06</span>),
+                              (<span class="n">0.15</span>, <span class="n">0.16</span>), (<span class="n">0.165</span>, <span class="n">0.175</span>), (<span class="n">0.165</span>, <span class="n">0.20</span>), (<span class="n">0.15</span>, <span class="n">0.215</span>),
+                              (<span class="n">0.15</span>, <span class="n">0.22</span>), (<span class="n">0.0</span>, <span class="n">0.22</span>)], <span class="n">16</span>,
+                 wear=(<span class="n">0</span>, <span class="n">0</span>, <span class="n">1</span>, <span class="n">0.3</span>, <span class="n">0</span>, <span class="n">0.3</span>, <span class="n">1</span>, <span class="n">0.3</span>, <span class="n">0</span>, <span class="n">0</span>), matrix=sm)
+    parts.append(neck)
+    parts.append(lathe(nm(<span class="s">&quot;Seal&quot;</span>), [(<span class="n">0.13</span>, <span class="n">0.215</span>), (<span class="n">0.188</span>, <span class="n">0.215</span>), (<span class="n">0.198</span>, <span class="n">0.225</span>),
+                                    (<span class="n">0.198</span>, <span class="n">0.25</span>), (<span class="n">0.188</span>, <span class="n">0.26</span>), (<span class="n">0.13</span>, <span class="n">0.26</span>)],
+                       <span class="n">16</span>, closed=<span class="k">True</span>, matrix=sm))
+    <span class="c"># cap: vertical skirt, then a dome in 22-deg steps (smooth by angle)</span>
+    cap_prof = [(<span class="n">0.0</span>, <span class="n">0.26</span>), (<span class="n">0.205</span>, <span class="n">0.26</span>), (<span class="n">0.205</span>, <span class="n">0.30</span>), (<span class="n">0.190</span>, <span class="n">0.337</span>),
+                (<span class="n">0.155</span>, <span class="n">0.373</span>), (<span class="n">0.091</span>, <span class="n">0.402</span>), (<span class="n">0.0</span>, <span class="n">0.405</span>)]
+    parts.append(lathe(nm(<span class="s">&quot;Cap&quot;</span>), cap_prof, <span class="n">16</span>, wear=(<span class="n">0</span>, <span class="n">0.5</span>, <span class="n">0.9</span>, <span class="n">0.3</span>, <span class="n">0</span>, <span class="n">0</span>, <span class="n">0</span>),
+                       matrix=sm))
+    lever = [(<span class="n">0.25</span>, <span class="n">0.27</span>), (<span class="n">0.27</span>, <span class="n">0.31</span>), (<span class="n">0.25</span>, <span class="n">0.36</span>), (<span class="n">0.18</span>, <span class="n">0.43</span>), (<span class="n">0.05</span>, <span class="n">0.445</span>),
+             (-<span class="n">0.24</span>, <span class="n">0.445</span>), (-<span class="n">0.30</span>, <span class="n">0.43</span>), (-<span class="n">0.30</span>, <span class="n">0.40</span>), (-<span class="n">0.22</span>, <span class="n">0.39</span>), (<span class="n">0.04</span>, <span class="n">0.41</span>),
+             (<span class="n">0.15</span>, <span class="n">0.395</span>), (<span class="n">0.20</span>, <span class="n">0.33</span>), (<span class="n">0.20</span>, <span class="n">0.29</span>)]
+    parts.append(extrude_profile(nm(<span class="s">&quot;CamLever&quot;</span>), lever, <span class="n">0.08</span>, <span class="n">0.008</span>, matrix=sm))
+    parts.append(lathe(nm(<span class="s">&quot;Hinge&quot;</span>), [(<span class="n">0.0</span>, -<span class="n">0.07</span>), (<span class="n">0.035</span>, -<span class="n">0.07</span>), (<span class="n">0.035</span>, <span class="n">0.07</span>), (<span class="n">0.0</span>, <span class="n">0.07</span>)],
+                       <span class="n">16</span>, matrix=sm @ Matrix.Translation((<span class="n">0.22</span>, <span class="n">0.0</span>, <span class="n">0.30</span>))
+                       @ Matrix.Rotation(math.radians(<span class="n">90</span>), <span class="n">4</span>, <span class="s">&#x27;X&#x27;</span>)))
+    parts.append(lathe(nm(<span class="s">&quot;LockPin&quot;</span>), [(<span class="n">0.0</span>, -<span class="n">0.075</span>), (<span class="n">0.024</span>, -<span class="n">0.075</span>), (<span class="n">0.024</span>, <span class="n">0.05</span>),
+                                       (<span class="n">0.04</span>, <span class="n">0.05</span>), (<span class="n">0.04</span>, <span class="n">0.075</span>), (<span class="n">0.0</span>, <span class="n">0.075</span>)],
+                       <span class="n">16</span>, wear=(<span class="n">0</span>, <span class="n">0</span>, <span class="n">0</span>, <span class="n">1</span>, <span class="n">1</span>, <span class="n">0</span>),
+                       matrix=sm @ Matrix.Translation((-<span class="n">0.26</span>, <span class="n">0.0</span>, <span class="n">0.42</span>))
+                       @ Matrix.Rotation(math.radians(-<span class="n">90</span>), <span class="n">4</span>, <span class="s">&#x27;X&#x27;</span>)))
+
+    <span class="k">return</span> {<span class="s">&quot;shell&quot;</span>: shell, <span class="s">&quot;handle&quot;</span>: handle, <span class="s">&quot;neck&quot;</span>: neck, <span class="s">&quot;parts&quot;</span>: parts}
 
 
 <span class="c"># ---------------------------------------------------------------------------</span>
@@ -655,13 +877,37 @@ <h2>Source</h2>
 
 <span class="k">def</span> check_custom_normals_roundtrip(obj):
     <span class="s">&quot;&quot;&quot;Per-loop custom normals survive depsgraph evaluation. Tolerance is the
-    int16 storage quantization, measured 7.5e-05 on both versions.&quot;&quot;&quot;</span>
+    int16 storage quantization, measured 7.5e-05 on both versions.
+
+    Each corner requests its face normal tilted CUSTOM_TILT toward the
+    corner bisector — a distinct normal per corner, as a weighted-normal or
+    bevel-softening pass writes. Blender&#x27;s encoder (the lnor-space
+    LNOR_SPACE_TRIGO_THRESHOLD, dot &gt; 1 - 1e-4, ~0.81 deg) is not storage
+    precision and must stay out of the measurement: requested normals in one
+    fan closer than that are MERGED to their average (a pattern stepping
+    ~7e-4 rad per loop over 4.5k loops measured 1.4e-02), and an in-plane
+    angle from the space&#x27;s reference edge under it is SNAPPED to zero (an
+    arbitrary-direction pattern put 13 of 4.5k corners there, 9.1e-03).
+    Aimed at the bisector, the in-plane angle is half the corner — never
+    near zero on this mesh — so the round-trip isolates quantization.&quot;&quot;&quot;</span>
     me = obj.data
     n = len(me.loops)
-    custom = []
-    <span class="k">for</span> i <span class="k">in</span> range(n):
-        a = <span class="n">2.0</span> * math.pi * i / n
-        custom.append(Vector((<span class="n">0.5</span> * math.cos(a), <span class="n">0.5</span> * math.sin(a), <span class="n">0.85</span>)).normalized())
+    custom = [<span class="k">None</span>] * n
+    co = [v.co <span class="k">for</span> v <span class="k">in</span> me.vertices]
+    <span class="k">for</span> poly <span class="k">in</span> me.polygons:
+        fn = poly.normal
+        vs = poly.vertices
+        k = len(vs)
+        <span class="k">for</span> j <span class="k">in</span> range(k):
+            c = co[vs[j]]
+            e_prev = (co[vs[j - <span class="n">1</span>]] - c).normalized()
+            e_next = (co[vs[(j + <span class="n">1</span>) % k]] - c).normalized()
+            bis = e_prev + e_next
+            bis -= fn * bis.dot(fn)
+            <span class="k">if</span> bis.length &lt; <span class="n">1e-6</span>:           <span class="c"># straight corner: perpendicular in-plane</span>
+                bis = fn.cross(e_next)
+            custom[poly.loop_start + j] = (fn * math.cos(CUSTOM_TILT)
+                                           + bis.normalized() * math.sin(CUSTOM_TILT))
     me.normals_split_custom_set(custom)
     <span class="k">if</span> <span class="k">not</span> me.has_custom_normals:
         print(<span class="s">&quot;ERROR: has_custom_normals False after normals_split_custom_set — &quot;</span>
@@ -725,68 +971,168 @@ <h2>Source</h2>
 
 
 <span class="c"># ---------------------------------------------------------------------------</span>
-<span class="c"># Render: the same can three ways — flat (faceting), smooth-everywhere (the</span>
-<span class="c"># smeared AI bug), by-angle (the contract). Failure modes flank the truth.</span>
+<span class="c"># Render: three fresh builds of the same can, one per shading treatment —</span>
+<span class="c"># flat (every facet shows), smooth-everywhere (the shade_smooth-and-forget</span>
+<span class="c"># AI habit: flat faces smear into gradients, pressed panels go pillowy),</span>
+<span class="c"># and by-angle (the contract). Failure modes flank the truth.</span>
 <span class="c"># ---------------------------------------------------------------------------</span>
 
 <span class="k">def</span> eevee_engine_id():
     <span class="k">return</span> <span class="s">&#x27;BLENDER_EEVEE&#x27;</span> <span class="k">if</span> bpy.app.version &gt;= (<span class="n">5</span>, <span class="n">0</span>, <span class="n">0</span>) <span class="k">else</span> <span class="s">&#x27;BLENDER_EEVEE_NEXT&#x27;</span>
 
 
-<span class="k">def</span> make_material(name, color, metallic, roughness):
+<span class="k">def</span> make_material(name, color, metallic, roughness, coat=<span class="n">0.0</span>):
     mat = bpy.data.materials.new(name)
     mat.use_nodes = <span class="k">True</span>
     bsdf = mat.node_tree.nodes[<span class="s">&quot;Principled BSDF&quot;</span>]
     bsdf.inputs[<span class="s">&quot;Base Color&quot;</span>].default_value = (*color, <span class="n">1.0</span>)
     bsdf.inputs[<span class="s">&quot;Metallic&quot;</span>].default_value = metallic
     bsdf.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = roughness
+    <span class="k">if</span> coat:
+        bsdf.inputs[<span class="s">&quot;Coat Weight&quot;</span>].default_value = coat
+        bsdf.inputs[<span class="s">&quot;Coat Roughness&quot;</span>].default_value = <span class="n">0.12</span>
     <span class="k">return</span> mat
 
 
-<span class="k">def</span> variant_meshes(parts, mode):
-    <span class="s">&quot;&quot;&quot;Fresh mesh copies with one shading treatment applied.&quot;&quot;&quot;</span>
-    out = []
+<span class="k">def</span> make_painted_steel(name, paint, steel):
+    <span class="s">&quot;&quot;&quot;Semi-gloss paint over steel, chipped where the `wear` attribute says
+    an edge is exposed. Glossy enough (coat) that a highlight exposes every
+    normal discontinuity — matte paint would hide the very differences this
+    render exists to show.&quot;&quot;&quot;</span>
+    mat = bpy.data.materials.new(name)
+    mat.use_nodes = <span class="k">True</span>
+    nt = mat.node_tree
+    nodes, links = nt.nodes, nt.links
+    out = nodes[<span class="s">&quot;Material Output&quot;</span>]
+    paint_bsdf = nodes[<span class="s">&quot;Principled BSDF&quot;</span>]
+    paint_bsdf.inputs[<span class="s">&quot;Base Color&quot;</span>].default_value = (*paint, <span class="n">1.0</span>)
+    paint_bsdf.inputs[<span class="s">&quot;Metallic&quot;</span>].default_value = <span class="n">0.0</span>
+    paint_bsdf.inputs[<span class="s">&quot;Coat Weight&quot;</span>].default_value = <span class="n">0.35</span>
+    paint_bsdf.inputs[<span class="s">&quot;Coat Roughness&quot;</span>].default_value = <span class="n">0.18</span>
+    steel_bsdf = nodes.new(<span class="s">&quot;ShaderNodeBsdfPrincipled&quot;</span>)
+    steel_bsdf.inputs[<span class="s">&quot;Base Color&quot;</span>].default_value = (*steel, <span class="n">1.0</span>)
+    steel_bsdf.inputs[<span class="s">&quot;Metallic&quot;</span>].default_value = <span class="n">1.0</span>
+    steel_bsdf.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.32</span>
+
+    coord = nodes.new(<span class="s">&quot;ShaderNodeTexCoord&quot;</span>)
+    chips = nodes.new(<span class="s">&quot;ShaderNodeTexNoise&quot;</span>)
+    chips.inputs[<span class="s">&quot;Scale&quot;</span>].default_value = <span class="n">18.0</span>
+    chips.inputs[<span class="s">&quot;Detail&quot;</span>].default_value = <span class="n">6.0</span>
+    links.new(coord.outputs[<span class="s">&quot;Object&quot;</span>], chips.inputs[<span class="s">&quot;Vector&quot;</span>])
+    mottle = nodes.new(<span class="s">&quot;ShaderNodeTexNoise&quot;</span>)
+    mottle.inputs[<span class="s">&quot;Scale&quot;</span>].default_value = <span class="n">4.0</span>
+    links.new(coord.outputs[<span class="s">&quot;Object&quot;</span>], mottle.inputs[<span class="s">&quot;Vector&quot;</span>])
+    rough = nodes.new(<span class="s">&quot;ShaderNodeMapRange&quot;</span>)
+    rough.inputs[<span class="s">&quot;To Min&quot;</span>].default_value = <span class="n">0.30</span>
+    rough.inputs[<span class="s">&quot;To Max&quot;</span>].default_value = <span class="n">0.46</span>
+    links.new(mottle.outputs[<span class="s">&quot;Fac&quot;</span>], rough.inputs[<span class="s">&quot;Value&quot;</span>])
+    links.new(rough.outputs[<span class="s">&quot;Result&quot;</span>], paint_bsdf.inputs[<span class="s">&quot;Roughness&quot;</span>])
+
+    wear = nodes.new(<span class="s">&quot;ShaderNodeAttribute&quot;</span>)
+    wear.attribute_name = WEAR
+    <span class="c"># chip = wear + (noise - 0.5) * 1.6, thresholded to a crisp paint edge</span>
+    jitter = nodes.new(<span class="s">&quot;ShaderNodeMath&quot;</span>)
+    jitter.operation = <span class="s">&#x27;MULTIPLY_ADD&#x27;</span>
+    jitter.inputs[<span class="n">1</span>].default_value = <span class="n">1.6</span>
+    jitter.inputs[<span class="n">2</span>].default_value = -<span class="n">0.8</span>
+    links.new(chips.outputs[<span class="s">&quot;Fac&quot;</span>], jitter.inputs[<span class="n">0</span>])
+    total = nodes.new(<span class="s">&quot;ShaderNodeMath&quot;</span>)
+    total.operation = <span class="s">&#x27;ADD&#x27;</span>
+    links.new(wear.outputs[<span class="s">&quot;Fac&quot;</span>], total.inputs[<span class="n">0</span>])
+    links.new(jitter.outputs[<span class="s">&quot;Value&quot;</span>], total.inputs[<span class="n">1</span>])
+    mask = nodes.new(<span class="s">&quot;ShaderNodeMapRange&quot;</span>)
+    mask.inputs[<span class="s">&quot;From Min&quot;</span>].default_value = <span class="n">0.86</span>
+    mask.inputs[<span class="s">&quot;From Max&quot;</span>].default_value = <span class="n">0.92</span>
+    links.new(total.outputs[<span class="s">&quot;Value&quot;</span>], mask.inputs[<span class="s">&quot;Value&quot;</span>])
+
+    mix = nodes.new(<span class="s">&quot;ShaderNodeMixShader&quot;</span>)
+    links.new(mask.outputs[<span class="s">&quot;Result&quot;</span>], mix.inputs[<span class="s">&quot;Fac&quot;</span>])
+    links.new(paint_bsdf.outputs[<span class="s">&quot;BSDF&quot;</span>], mix.inputs[<span class="n">1</span>])
+    links.new(steel_bsdf.outputs[<span class="s">&quot;BSDF&quot;</span>], mix.inputs[<span class="n">2</span>])
+    links.new(mix.outputs[<span class="s">&quot;Shader&quot;</span>], out.inputs[<span class="s">&quot;Surface&quot;</span>])
+    <span class="k">return</span> mat
+
+
+PART_MATERIAL = {<span class="s">&quot;CamLever&quot;</span>: <span class="s">&quot;steel&quot;</span>, <span class="s">&quot;Hinge&quot;</span>: <span class="s">&quot;steel&quot;</span>, <span class="s">&quot;LockPin&quot;</span>: <span class="s">&quot;steel&quot;</span>, <span class="s">&quot;Seal&quot;</span>: <span class="s">&quot;seal&quot;</span>}
+
+
+<span class="k">def</span> shade(parts, mode):
+    <span class="s">&quot;&quot;&quot;The one variable across the three cans.&quot;&quot;&quot;</span>
     <span class="k">for</span> o <span class="k">in</span> parts:
-        me = o.data.copy()
-        me.name = <span class="s">f&quot;</span>{o.name}<span class="s">_</span>{mode}<span class="s">&quot;</span>
+        me = o.data
         <span class="k">for</span> p <span class="k">in</span> me.polygons:
             p.use_smooth = mode != <span class="s">&quot;flat&quot;</span>
         <span class="k">if</span> mode == <span class="s">&quot;byangle&quot;</span>:
             me.set_sharp_from_angle(angle=ANGLE)
-        dup = bpy.data.objects.new(<span class="s">f&quot;</span>{o.name}<span class="s">_</span>{mode}<span class="s">&quot;</span>, me)
-        dup.location = o.location
-        dup.rotation_euler = o.rotation_euler
-        bpy.context.collection.objects.link(dup)
-        out.append(dup)
-    <span class="k">return</span> out
+
+
+<span class="k">def</span> sharp_edge_overlay(parts, name, radius=<span class="n">0.0026</span>):
+    <span class="s">&quot;&quot;&quot;Thin tubes along every edge the `sharp_edge` attribute marks — the
+    contract&#x27;s own output drawn onto the by-angle can, read back from the
+    mesh rather than recomputed.&quot;&quot;&quot;</span>
+    bm = bmesh.new()
+    <span class="k">try</span>:
+        <span class="k">for</span> o <span class="k">in</span> parts:
+            me = o.data
+            attr = me.attributes.get(<span class="s">&quot;sharp_edge&quot;</span>)
+            <span class="k">if</span> attr <span class="k">is</span> <span class="k">None</span>:
+                <span class="k">continue</span>
+            <span class="k">for</span> e, d <span class="k">in</span> zip(me.edges, attr.data):
+                <span class="k">if</span> <span class="k">not</span> d.value:
+                    <span class="k">continue</span>
+                a, b = (me.vertices[i].co <span class="k">for</span> i <span class="k">in</span> e.vertices)
+                t = (b - a).normalized()
+                u = t.orthogonal().normalized()
+                w = t.cross(u)
+                ring = []
+                <span class="k">for</span> k <span class="k">in</span> range(<span class="n">4</span>):
+                    ang = math.pi * <span class="n">0.5</span> * k
+                    off = (u * math.cos(ang) + w * math.sin(ang)) * radius
+                    ring.append((bm.verts.new(a + off), bm.verts.new(b + off)))
+                <span class="k">for</span> k <span class="k">in</span> range(<span class="n">4</span>):
+                    (a0, b0), (a1, b1) = ring[k], ring[(k + <span class="n">1</span>) % <span class="n">4</span>]
+                    bm.faces.new((a0, a1, b1, b0))
+        me = bpy.data.meshes.new(name)
+        bm.to_mesh(me)
+    <span class="k">finally</span>:
+        bm.free()
+    obj = bpy.data.objects.new(name, me)
+    bpy.context.collection.objects.link(obj)
+    <span class="k">return</span> obj
 
 
 <span class="k">def</span> render_still(can, path, engine):
     scene = bpy.context.scene
-    <span class="c"># semi-gloss painted steel: rough enough to read as paint, glossy enough</span>
-    <span class="c"># that a highlight exposes every normal discontinuity — matte would hide</span>
-    <span class="c"># the very shading differences this render exists to show</span>
-    steel = make_material(<span class="s">&quot;OliveDrab&quot;</span>, (<span class="n">0.30</span>, <span class="n">0.345</span>, <span class="n">0.13</span>), <span class="n">0.8</span>, <span class="n">0.26</span>)
-    accent = make_material(<span class="s">&quot;FuelMarker&quot;</span>, (<span class="n">0.55</span>, <span class="n">0.06</span>, <span class="n">0.03</span>), <span class="n">0.3</span>, <span class="n">0.30</span>)
-
-    <span class="c"># the checked base can IS the by-angle variant; the two failure modes are</span>
-    <span class="c"># mesh copies with their own shading, no materials yet</span>
-    variants = []
-    <span class="k">for</span> mode, x <span class="k">in</span> ((<span class="s">&quot;flat&quot;</span>, -<span class="n">1.5</span>), (<span class="s">&quot;smooth&quot;</span>, <span class="n">0.0</span>), (<span class="s">&quot;byangle&quot;</span>, <span class="n">1.5</span>)):
-        objs = variant_meshes(can[<span class="s">&quot;parts&quot;</span>], mode)
-        <span class="k">for</span> o <span class="k">in</span> objs:
-            o.location.x += x
-            o.rotation_euler.z += math.radians(-<span class="n">10.0</span>)  <span class="c"># uniform yaw, fronts to camera</span>
-            o.data.materials.append(steel)
-            <span class="k">if</span> o.name.startswith(<span class="s">&quot;Cap&quot;</span>):
-                o.data.materials.append(accent)
-                <span class="k">for</span> p <span class="k">in</span> o.data.polygons:  <span class="c"># cap rim ring in the marker red</span>
-                    <span class="k">if</span> p.center.z &lt; <span class="n">0.045</span>:
-                        p.material_index = <span class="n">1</span>
-        variants.append(objs)
-    <span class="c"># hide the checked originals: the byangle variant re-shows the same data</span>
+    mats = {
+        <span class="s">&quot;paint&quot;</span>: make_painted_steel(<span class="s">&quot;OlivePaint&quot;</span>, (<span class="n">0.085</span>, <span class="n">0.115</span>, <span class="n">0.030</span>), (<span class="n">0.30</span>, <span class="n">0.30</span>, <span class="n">0.29</span>)),
+        <span class="s">&quot;steel&quot;</span>: make_material(<span class="s">&quot;BareSteel&quot;</span>, (<span class="n">0.42</span>, <span class="n">0.41</span>, <span class="n">0.39</span>), <span class="n">1.0</span>, <span class="n">0.34</span>),
+        <span class="s">&quot;seal&quot;</span>: make_material(<span class="s">&quot;SealRed&quot;</span>, (<span class="n">0.62</span>, <span class="n">0.035</span>, <span class="n">0.02</span>), <span class="n">0.0</span>, <span class="n">0.42</span>),
+    }
+
+    <span class="c"># the checked can stays hidden; the gallery shows three fresh builds</span>
     <span class="k">for</span> o <span class="k">in</span> can[<span class="s">&quot;parts&quot;</span>]:
         o.hide_render = <span class="k">True</span>
+    variants = {}
+    <span class="k">for</span> mode, x <span class="k">in</span> ((<span class="s">&quot;flat&quot;</span>, -<span class="n">1.62</span>), (<span class="s">&quot;smooth&quot;</span>, <span class="n">0.0</span>), (<span class="s">&quot;byangle&quot;</span>, <span class="n">1.62</span>)):
+        built = build_jerry_can(<span class="s">&quot;_&quot;</span> + mode)[<span class="s">&quot;parts&quot;</span>]
+        shade(built, mode)
+        <span class="k">for</span> o <span class="k">in</span> built:
+            base = o.name[: -len(mode) - <span class="n">1</span>].rstrip(<span class="s">&quot;0123456789&quot;</span>)
+            o.data.materials.append(mats[PART_MATERIAL.get(base, <span class="s">&quot;paint&quot;</span>)])
+            o.location = (x, <span class="n">0.0</span>, <span class="n">0.0</span>)
+            o.rotation_euler = (<span class="n">0.0</span>, <span class="n">0.0</span>, math.radians(-<span class="n">30.0</span>))
+        variants[mode] = built
+    hero = [o <span class="k">for</span> objs <span class="k">in</span> variants.values() <span class="k">for</span> o <span class="k">in</span> objs]
+    edges = sharp_edge_overlay(variants[<span class="s">&quot;byangle&quot;</span>], <span class="s">&quot;SharpEdgeOverlay&quot;</span>)
+    glow = bpy.data.materials.new(<span class="s">&quot;SharpEdgeGlow&quot;</span>)
+    glow.use_nodes = <span class="k">True</span>
+    gb = glow.node_tree.nodes[<span class="s">&quot;Principled BSDF&quot;</span>]
+    gb.inputs[<span class="s">&quot;Base Color&quot;</span>].default_value = (<span class="n">0.35</span>, <span class="n">0.85</span>, <span class="n">1.0</span>, <span class="n">1.0</span>)
+    gb.inputs[<span class="s">&quot;Emission Color&quot;</span>].default_value = (<span class="n">0.35</span>, <span class="n">0.85</span>, <span class="n">1.0</span>, <span class="n">1.0</span>)
+    gb.inputs[<span class="s">&quot;Emission Strength&quot;</span>].default_value = <span class="n">1.0</span>
+    edges.data.materials.append(glow)
+    edges.location = variants[<span class="s">&quot;byangle&quot;</span>][<span class="n">0</span>].location
+    edges.rotation_euler = variants[<span class="s">&quot;byangle&quot;</span>][<span class="n">0</span>].rotation_euler
 
     floor_me = bpy.data.meshes.new(<span class="s">&quot;Floor&quot;</span>)
     bm = bmesh.new()
@@ -795,12 +1141,11 @@ <h2>Source</h2>
         bm.to_mesh(floor_me)
     <span class="k">finally</span>:
         bm.free()
-    fmat = make_material(<span class="s">&quot;Studio&quot;</span>, (<span class="n">0.03</span>, <span class="n">0.032</span>, <span class="n">0.037</span>), <span class="n">0.0</span>, <span class="n">0.7</span>)
-    floor_me.materials.append(fmat)
+    floor_me.materials.append(make_material(<span class="s">&quot;Studio&quot;</span>, (<span class="n">0.03</span>, <span class="n">0.032</span>, <span class="n">0.037</span>), <span class="n">0.0</span>, <span class="n">0.7</span>))
     floor = bpy.data.objects.new(<span class="s">&quot;Floor&quot;</span>, floor_me)
     scene.collection.objects.link(floor)
     wall = bpy.data.objects.new(<span class="s">&quot;Wall&quot;</span>, floor_me.copy())
-    wall.location = (<span class="n">0.0</span>, <span class="n">11.0</span>, <span class="n">0.0</span>)
+    wall.location = (<span class="n">0.0</span>, <span class="n">9.0</span>, <span class="n">0.0</span>)
     wall.rotation_euler = (math.radians(<span class="n">90</span>), <span class="n">0.0</span>, <span class="n">0.0</span>)
     scene.collection.objects.link(wall)
 
@@ -809,40 +1154,37 @@ <h2>Source</h2>
     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):
+    <span class="k">def</span> light(name, loc, energy, size, col, rot, size_y=<span class="k">None</span>):
         ld = bpy.data.lights.new(name, <span class="s">&#x27;AREA&#x27;</span>)
-        ld.energy = energy; ld.size = size; ld.color = col
+        ld.energy = energy
+        ld.color = col
+        ld.size = size
+        <span class="k">if</span> size_y <span class="k">is</span> <span class="k">not</span> <span class="k">None</span>:
+            ld.shape = <span class="s">&#x27;RECTANGLE&#x27;</span>
+            ld.size_y = size_y
         ob = bpy.data.objects.new(name, ld)
         ob.location = loc
         ob.rotation_euler = tuple(math.radians(a) <span class="k">for</span> a <span class="k">in</span> rot)
         scene.collection.objects.link(ob)
+        <span class="k">return</span> ob
 
     <span class="c"># key/fill/rim/wedge 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">520.0</span>, <span class="n">4.5</span>, (<span class="n">1.0</span>, <span class="n">0.96</span>, <span class="n">0.9</span>), (<span class="n">50</span>, <span class="n">0</span>, -<span class="n">38</span>))
-    light(<span class="s">&quot;Fill&quot;</span>, (<span class="n">5.5</span>, -<span class="n">3.5</span>, <span class="n">2.5</span>), <span class="n">150.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">55</span>))
-    light(<span class="s">&quot;Rim&quot;</span>, (<span class="n">1.5</span>, <span class="n">4.5</span>, <span class="n">4.0</span>), <span class="n">340.0</span>, <span class="n">3.0</span>, (<span class="n">0.6</span>, <span class="n">0.78</span>, <span class="n">1.0</span>), (-<span class="n">58</span>, <span class="n">0</span>, <span class="n">170</span>))
-    light(<span class="s">&quot;Wedge&quot;</span>, (<span class="n">2.5</span>, <span class="n">5.5</span>, <span class="n">4.0</span>), <span class="n">400.0</span>, <span class="n">6.0</span>, (<span class="n">1.0</span>, <span class="n">0.76</span>, <span class="n">0.5</span>), (-<span class="n">68</span>, <span class="n">0</span>, <span class="n">190</span>))
-    <span class="c"># the shading audit light: a tall strip whose reflection runs down each</span>
-    <span class="c"># can face — it stair-steps on flat shading, warps at the rim on</span>
-    <span class="c"># smooth-everything, and stays straight with crisp edges on by-angle</span>
-    ld = bpy.data.lights.new(<span class="s">&quot;Strip&quot;</span>, <span class="s">&#x27;AREA&#x27;</span>)
-    ld.energy = <span class="n">400.0</span>
-    ld.shape = <span class="s">&#x27;RECTANGLE&#x27;</span>
-    ld.size = <span class="n">1.35</span>
-    ld.size_y = <span class="n">8.0</span>
-    ld.color = (<span class="n">0.9</span>, <span class="n">0.95</span>, <span class="n">1.0</span>)
-    strip = bpy.data.objects.new(<span class="s">&quot;Strip&quot;</span>, ld)
-    strip.location = (-<span class="n">3.5</span>, -<span class="n">4.5</span>, <span class="n">3.2</span>)
-    strip.rotation_euler = (math.radians(<span class="n">60</span>), <span class="n">0.0</span>, math.radians(-<span class="n">30</span>))
-    scene.collection.objects.link(strip)
+    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">560.0</span>, <span class="n">4.5</span>, (<span class="n">1.0</span>, <span class="n">0.96</span>, <span class="n">0.9</span>), (<span class="n">50</span>, <span class="n">0</span>, -<span class="n">38</span>))
+    light(<span class="s">&quot;Fill&quot;</span>, (<span class="n">5.5</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">55</span>))
+    light(<span class="s">&quot;Rim&quot;</span>, (<span class="n">1.5</span>, <span class="n">4.5</span>, <span class="n">4.0</span>), <span class="n">320.0</span>, <span class="n">3.0</span>, (<span class="n">0.6</span>, <span class="n">0.78</span>, <span class="n">1.0</span>), (-<span class="n">58</span>, <span class="n">0</span>, <span class="n">170</span>))
+    light(<span class="s">&quot;Wedge&quot;</span>, (<span class="n">1.2</span>, <span class="n">6.2</span>, <span class="n">3.0</span>), <span class="n">500.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">70</span>, <span class="n">0</span>, <span class="n">12</span>))
+    <span class="c"># the shading audit light: a tall narrow strip low on the camera&#x27;s left.</span>
+    <span class="c"># The pressed faces mirror it: a straight band broken cleanly at every</span>
+    <span class="c"># crease on by-angle, stepped on flat, bent into a smear on smooth.</span>
+    light(<span class="s">&quot;Strip&quot;</span>, (-<span class="n">5.2</span>, -<span class="n">5.6</span>, <span class="n">1.4</span>), <span class="n">320.0</span>, <span class="n">0.6</span>, (<span class="n">0.92</span>, <span class="n">0.96</span>, <span class="n">1.0</span>), (<span class="n">90</span>, <span class="n">0</span>, -<span class="n">42</span>), size_y=<span class="n">6.0</span>)
 
     cam_data = bpy.data.cameras.new(<span class="s">&quot;Cam&quot;</span>)
     cam_data.lens = <span class="n">50.0</span>
     cam = bpy.data.objects.new(<span class="s">&quot;Cam&quot;</span>, cam_data)
-    cam.location = (<span class="n">1.9</span>, -<span class="n">7.2</span>, <span class="n">2.6</span>)
+    cam.location = (<span class="n">0.77</span>, -<span class="n">8.0</span>, <span class="n">2.8</span>)
     scene.collection.objects.link(cam)
     target = bpy.data.objects.new(<span class="s">&quot;Aim&quot;</span>, <span class="k">None</span>)
-    target.location = (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">1.05</span>)
+    target.location = (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">1.08</span>)
     scene.collection.objects.link(target)
     con = cam.constraints.new(<span class="s">&#x27;TRACK_TO&#x27;</span>)
     con.target = target
@@ -862,8 +1204,21 @@ <h2>Source</h2>
     scene.render.filepath = path
     <span class="c"># AgX would flatten the olive drab toward mud (docs/VISUAL-STYLE.md)</span>
     scene.view_settings.view_transform = <span class="s">&#x27;Standard&#x27;</span>
+    bpy.context.view_layer.update()
+
+    fcode = gallery_framing.check_framing(scene, cam, hero=hero, elements=hero + [edges],
+                                          stage=[floor, wall])
+    <span class="k">if</span> fcode:
+        <span class="k">return</span> fcode
+    aqcode = gallery_asset_quality.check_asset_quality(scene, cam, hero=variants[<span class="s">&quot;byangle&quot;</span>],
+                                                       stage=[floor, wall])
+    <span class="k">if</span> aqcode:
+        <span class="k">return</span> aqcode
     bpy.ops.render.render(write_still=<span class="k">True</span>)
-    <span class="k">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">9</span>
+    <span class="k">return</span> <span class="n">0</span>
 
 
 <span class="k">def</span> main():
@@ -881,7 +1236,7 @@ <h2>Source</h2>
 
     <span class="k">for</span> step <span class="k">in</span> (<span class="k">lambda</span>: check_api_surface(can[<span class="s">&quot;shell&quot;</span>].data),
                  <span class="k">lambda</span>: check_by_angle(
-                     [can[<span class="s">&quot;shell&quot;</span>], can[<span class="s">&quot;rib&quot;</span>], can[<span class="s">&quot;neck&quot;</span>]],
+                     [can[<span class="s">&quot;shell&quot;</span>], can[<span class="s">&quot;handle&quot;</span>], can[<span class="s">&quot;neck&quot;</span>]],
                      mismatch_angle=args.mismatch_angle),
                  <span class="k">lambda</span>: check_normal_welds(can[<span class="s">&quot;shell&quot;</span>]),
                  <span class="k">lambda</span>: check_custom_normals_roundtrip(can[<span class="s">&quot;shell&quot;</span>]),
@@ -891,9 +1246,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(can, 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">9</span>
+        code = render_still(can, 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;custom-normals-shade OK&quot;</span>)
@@ -910,7 +1265,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/custom-normals-shade-hero.webp" alt="Three olive jerry cans with embossed X ribs, shaded flat, smooth and smooth-by-angle." />
+    <img src="../assets/custom-normals-shade-hero.webp" alt="Three olive jerry cans with X-pressed panels, triple handles and red-sealed spouts: faceted flat, glossy-smeared smooth-everywhere, and crisp by-angle with its sharp edges traced in thin cyan lines." />
   </dialog>
   <footer>
     <div class="statusbar">
diff --git a/docs/gallery/index.html b/docs/gallery/index.html
index 5c944113..00fdc052 100644
--- a/docs/gallery/index.html
+++ b/docs/gallery/index.html
@@ -706,12 +706,12 @@ <h2><a href="collision-hull-proxy/">collision-hull-proxy</a></h2>
       </article>
       <article class="card" data-tags="mesh attributes">
         <a class="card-media" href="custom-normals-shade/" tabindex="-1" aria-hidden="true">
-          <img src="assets/custom-normals-shade-hero.webp" alt="Three olive jerry cans with embossed X ribs, shaded flat, smooth and smooth-by-angle." loading="lazy" decoding="async" />
+          <img src="assets/custom-normals-shade-hero.webp" alt="Three olive jerry cans with X-pressed panels, triple handles and red-sealed spouts: faceted flat, glossy-smeared smooth-everywhere, and crisp by-angle with its sharp edges traced in thin cyan lines." loading="lazy" decoding="async" />
         </a>
         <div class="card-body">
           <h2><a href="custom-normals-shade/">custom-normals-shade</a></h2>
-          <p class="teaches">A jerry can prop shaded three ways to prove the post-4.1 shading contract: hard edges are mesh data, landing exactly where the dihedral crosses. Face smooth flags plus a sharp_edge attribute, verified against an independently recomputed dihedral test, and per-loop custom normals surviving depsgraph evaluation within their int16 storage quantization (1.407e-04, not float-exact).</p>
-          <p class="witnesses"><span class="tag">witnesses</span> use_auto_smooth, use_custom_normals and calc_normals are AttributeError on BOTH 4.5 LTS and 5.1 - AI code still emits them. The legacy shade_auto_smooth operator CANCELS headless on 4.5 (asset load never finishes; mesh untouched; no exception) while 5.1 FINISHES with the Smooth by Angle NODES modifier. By-angle sharp sets match the independent dihedral recompute exactly (188 of 388 edges over 3 meshes).</p>
+          <p class="teaches">A jerry can prop shaded three ways to prove the post-4.1 shading contract: hard edges are mesh data, landing exactly where the dihedral crosses. Face smooth flags plus a sharp_edge attribute, verified against an independently recomputed dihedral test, and per-loop custom normals surviving depsgraph evaluation within their int16 storage quantization (3.904e-05 over 8196 loops, not float-exact).</p>
+          <p class="witnesses"><span class="tag">witnesses</span> use_auto_smooth, use_custom_normals and calc_normals are AttributeError on BOTH 4.5 LTS and 5.1 - AI code still emits them. The legacy shade_auto_smooth operator CANCELS headless on 4.5 (asset load never finishes; mesh untouched; no exception) while 5.1 FINISHES with the Smooth by Angle NODES modifier. By-angle sharp sets match the independent dihedral recompute exactly (1304 of 4738 edges over 3 meshes).</p>
           <a class="card-link" href="custom-normals-shade/">View example<span class="sr-only"> custom-normals-shade</span> <span aria-hidden="true">&rarr;</span></a>
         </div>
       </article>
diff --git a/examples/custom-normals-shade/README.md b/examples/custom-normals-shade/README.md
index 4103c494..30514029 100644
--- a/examples/custom-normals-shade/README.md
+++ b/examples/custom-normals-shade/README.md
@@ -1,7 +1,11 @@
 # Custom Normals + Shade by Angle
 
-A runnable example that builds a jerry can prop — rounded-slab shell,
-pressed X ribs, spout and cap, three-post handle — and verifies the shading
+A runnable example that builds a jerry can prop — a pressed-steel shell
+whose front and back carry four raised rounded-triangle panels (the X is
+the channel between them), a weld-seam bead round the side band, a triple
+carry handle on welded feet, and a spout with red seal, domed cap, cam
+lever, hinge and locking pin; olive paint chipped to steel on exposed edges
+by a `wear` point attribute — and verifies the shading
 contract a game prop's silhouette depends on: which edges read hard and
 which read smooth is mesh DATA, carried since Blender 4.1 by face smooth
 flags plus a `sharp_edge` attribute,
@@ -28,18 +32,25 @@ It is not an engine exporter and does not claim engine/FiveM compatibility
 - **Shade-by-angle is exact.** `mesh.set_sharp_from_angle(30°)` (which also
   sets the face smooth flags — probed on both versions) marks sharp exactly
   the edges whose *independently recomputed* dihedral angle crosses the
-  threshold: Shell 48 of 72 edges, rib 12 of 12, neck 128 of 304 — an exact
-  set match, not a count approximation.
+  threshold: Shell 1144 of 4098 edges, Handle 32 of 368, Neck 128 of 272
+  (1304 of 4738) — an exact set match, not a count approximation.
 - **The evaluated shading matches the attribute's promise.** Through
   depsgraph evaluation, loop normals across a smooth edge are welded
-  (deviation 0.0, tol 1e-3) and loop normals across a sharp edge carry
-  their face normals split by exactly the dihedral (angle error 0.0 rad,
-  tol 5e-3), all unit length (err 5.6e-08).
+  (deviation 0.0, tol 1e-3) and loop normals across a sharp edge are split
+  by the dihedral (angle error 1.898e-03 rad, tol 5e-3 — the curved side
+  band and the panels' rounded wall corners average a fan whose facets
+  step at most 22.5 and 10 deg), all unit length (err 1.0e-07).
 - **Custom split normals survive depsgraph evaluation** — with a
   quantization budget, not float precision: `normals_split_custom_set`
-  stores per-loop normals in int16, so a 144-loop round-trip reads back
-  within **1.407e-04** (tol 2e-4), unit length within 1.1e-07. Asserting
-  float-exact custom normals is a real bug this check catches.
+  stores per-loop normals in int16, so an 8196-loop round-trip reads back
+  within **3.904e-05** (tol 2e-4), unit length within 1.7e-07. Asserting
+  float-exact custom normals is a real bug this check catches. Each corner
+  requests its face normal tilted 20 deg toward the corner bisector. The
+  pattern matters: Blender's lnor encoder merges requests within one fan
+  that sit closer than ~0.81 deg and snaps an in-plane angle under 0.81 deg
+  to zero. On this shell an index-swept pattern measured the merge
+  (1.38e-02) and a 144-direction cycle hit the snap on 13 corners
+  (9.1e-03). Neither is storage precision, so the check keeps clear of both.
 - **The divergence: the legacy `shade_auto_smooth` OPERATOR is a
   version-split trap.** It builds the Smooth-by-Angle node-group modifier
   from a bundled asset. Headless on **4.5 LTS the asset load never
@@ -50,22 +61,28 @@ It is not an engine exporter and does not claim engine/FiveM compatibility
   portable path is the data API above, version-gated here explicitly.
 
 **What each check catches on failure:** author/audit threshold drift
-(probe: sharp marks applied at 20° but audited at 30°, exit 5, 4 extra
-edges); the two halves of the contract out of sync (probe: `sharp_edge`
-set but face smooth flags lost, exit 6, smooth-edge loops split by
-3.83e-01); float-exactness assumed of custom normals (probe: tolerance
-1e-6, exit 7, measured 1.407e-04); and any future version that resurrects
-the legacy API or changes the operator's headless behavior (exit 3/8).
-
-**Version witness:** every value above is identical on Blender 4.5.11 LTS
-and 5.1.2 except the `shade_auto_smooth` operator behavior, which is
+(probe: sharp marks applied at 20° but audited at 30°, exit 5, 48 extra
+edges on the shell); the two halves of the contract out of sync (probe:
+`sharp_edge` set but face smooth flags lost, exit 6, smooth-edge loops
+split by 3.902e-01); float-exactness assumed of custom normals (probe:
+tolerance 1e-6, exit 7, measured 3.904e-05); and any future version that
+resurrects the legacy API or changes the operator's headless behavior
+(exit 3/8). The render path adds the Layer 1 gates: framing (exit 10) and
+asset quality (exit 11).
+
+**Version witness:** every value above is identical on Blender 4.5.11 LTS,
+5.1.2 and 5.2.1 LTS except the `shade_auto_smooth` operator behavior, which is
 asserted per version (CANCELLED + untouched on 4.5, FINISHED + NODES
-modifier on 5.1).
+modifier on 5.1 and 5.2).
 
-The render shows the same can shaded three ways — flat (faceted corners),
-smooth-everywhere (the smeared AI bug: ribs melt, highlights warp at the
-rim), and by-angle (the contract: smooth walls, crisp edges) — under a
-strip light whose reflection exposes every normal discontinuity.
+The render shows three fresh builds of the same can, one per shading
+treatment. Left, flat: the side-band corners, cap and handle break into
+facets. Middle, smooth-everywhere (the shade-smooth-and-forget AI habit):
+the flat fields smear into gradients and the pressed panels go pillowy.
+Right, by-angle (the contract): crisp creases and smooth rounds, with the
+`sharp_edge` attribute read back from the mesh and traced as thin cyan
+lines, so the viewer sees exactly which edges the data marked hard. A
+low strip light makes the highlight shapes diverge between the three.
 
 ## Run
 
@@ -98,6 +115,8 @@ against it.
 | 7 | Custom split normals lost or dequantized in evaluation |
 | 8 | `shade_auto_smooth` operator behavior drifted from the version split |
 | 9 | `--output` produced no file |
+| 10 | Render path: Layer 1 framing violation (`gallery_framing`) |
+| 11 | Render path: asset-quality floor violation (`gallery_asset_quality`) |
 
 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/custom-normals-shade/custom_normals_shade.py b/examples/custom-normals-shade/custom_normals_shade.py
index 99400560..ec739c39 100644
--- a/examples/custom-normals-shade/custom_normals_shade.py
+++ b/examples/custom-normals-shade/custom_normals_shade.py
@@ -18,7 +18,9 @@
                   carry their face normals (split by the dihedral)
   custom normals— per-loop normals set with `normals_split_custom_set`
                   survive depsgraph evaluation within the int16 storage
-                  quantization (~7.5e-05 measured, tol 2e-4), unit length
+                  quantization (3.9e-05 measured over 8196 loops, tol 2e-4),
+                  unit length; the request pattern stays clear of the
+                  encoder's 0.81-deg merge/snap threshold (see that check)
   divergence    — the legacy `shade_auto_smooth` OPERATOR needs the bundled
                   Smooth-by-Angle node-group asset: headless on 4.5 LTS it
                   returns {'CANCELLED'} ("Asset loading is unfinished") and
@@ -31,15 +33,25 @@
 (``--same-axis`` in export-preset-axis).
 
 By default it runs only the correctness check (no render) — the CI smoke
-check. Pass --output to also render a still (the same can shaded flat /
-smooth-everywhere / by-angle, so a broken path reads as faceting or smear):
+check. Pass --output to also render a still: three fresh builds of the can
+shaded flat (faceted corners, cap and handle), smooth-everywhere (the flat
+fields smear, the pressed panels go pillowy) and by-angle (crisp creases,
+smooth rounds), with the by-angle can's `sharp_edge` set read back from the
+mesh and traced as thin cyan lines. The render path is gated by
+gallery_framing (exit 10) and gallery_asset_quality (exit 11):
 
     blender --background --python custom_normals_shade.py --                 # check only
     blender --background --python custom_normals_shade.py -- --mismatch-angle
     blender --background --python custom_normals_shade.py -- --output c.png  # + render
 """
 import bpy, bmesh, sys, os, math, argparse
-from mathutils import Vector
+from mathutils import Matrix, Vector
+
+# Shared Layer 1 framing + asset-quality gates (render path only) — see
+# gallery_framing.py for the import contract.
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir))
+import gallery_framing  # noqa: E402
+import gallery_asset_quality  # noqa: E402
 
 ANGLE_DEG = 30.0          # shade-by-angle threshold
 ANGLE = math.radians(ANGLE_DEG)
@@ -47,15 +59,42 @@
 TOL_UNIT = 1e-6           # unit-length tolerance for evaluated normals (measured 4.5e-08)
 TOL_SMOOTH = 1e-3         # loop-normal equality across a welded (smooth) edge
 TOL_SHARP = 5e-3          # radians: split-normal angle vs dihedral across a sharp edge
+CUSTOM_TILT = math.radians(20.0)  # custom-normal round-trip request (see that check)
 
 # ---------------------------------------------------------------------------
-# Prop construction. A 20-unit jerry can: rounded-slab shell, pressed X ribs
-# floating on both faces, spout neck + cap, three-post carry handle. All
-# dimensions invented for this prop; ribs are floater prisms, the game-prop
-# norm — every checked mesh is itself closed and manifold.
+# Prop construction. A 20-litre-style jerry can in scene units: a pressed
+# steel shell (rounded side band, X-stamped front and back faces: four
+# raised rounded-triangle panels with 45-degree walls, the X is the channel
+# between them), a weld-seam bead round the band, a triple carry handle on
+# welded feet, and a spout with red seal, cap, cam lever, hinge and locking
+# pin. Every part is its own closed manifold mesh (the game-prop norm), and
+# the facet angles are chosen for the by-angle contract: curved surfaces
+# step at <= 22.5 deg (smooth under the 30 deg threshold), pressed creases
+# break at 45 or 90 deg (sharp), nothing sits near 30.
+#
+# A `wear` POINT attribute (1 on exposed convex edges, 0 a support ring
+# away) drives the paint-chip mask in the material; support rings are
+# coplanar, so they add no shading break and no dihedral.
 # ---------------------------------------------------------------------------
 
-SHELL_W, SHELL_H, SHELL_D, SHELL_R = 1.4, 1.8, 0.62, 0.28
+W, H, D = 1.30, 1.80, 0.62      # shell width (X), height (Z), depth (Y)
+R = 0.24                        # front-view corner radius of the side band
+CORNER_SEGS = 4                 # 22.5 deg facets: smooth under the threshold
+EDGE_BAND = 0.07                # side-band wear ring distance from each face
+FACE_BORDER = 0.04              # flat border inside the face outline
+PANEL_MARGIN = 0.015
+CHANNEL = 0.045                 # half-width of the X channel between panels
+PANEL_R = 0.09                  # panel base corner radius
+PRESS_H = 0.04                  # panel height; 45 deg walls (run == rise)
+ARC_STEP = 10.0                 # max degrees per panel-corner facet
+FIELD_STEP = 0.08               # max straight-run edge length (fill quality)
+WEAR = "wear"
+
+HANDLE_Y = 0.10
+HANDLE_X = (-0.50, -0.22, 0.06)  # left leg, centre post, right leg
+HANDLE_TOP = H + 0.26
+SPOUT_AT = (0.27, -0.07)
+SPOUT_TILT = 12.0               # degrees, leaning out over the corner
 
 
 def signed_volume(me):
@@ -69,9 +108,11 @@ def signed_volume(me):
     return vol
 
 
-def finish_mesh(name, bm):
+def finish_mesh(name, bm, matrix=None):
     me = bpy.data.meshes.new(name)
     try:
+        if matrix is not None:
+            bmesh.ops.transform(bm, matrix=matrix, verts=bm.verts)
         bmesh.ops.recalc_face_normals(bm, faces=bm.faces)
         bm.to_mesh(me)
     finally:
@@ -84,119 +125,300 @@ def finish_mesh(name, bm):
     return obj
 
 
-def rounded_rect_profile(w, h, r, segs):
-    """(x, z) loop of a rounded rectangle, z from 0 to h, CCW seen from -Y."""
+def rrect(inset, segs=CORNER_SEGS):
+    """(x, z) loop of the shell's front-view rounded rectangle, inset by
+    `inset`, CCW in (x, z). Corners include both arc ends, so the straight
+    runs between them are exactly axis-aligned; the runs are split every
+    ~FIELD_STEP so the pressed-face fill triangulates without slivers."""
+    rr = R - inset
+    cx = W / 2 - R
+    corners = ((cx, R, -90), (cx, H - R, 0), (-cx, H - R, 90), (-cx, R, 180))
     pts = []
-    for cx, cz, a0 in ((w / 2 - r, r, -90), (w / 2 - r, h - r, 0),
-                       (-(w / 2 - r), h - r, 90), (-(w / 2 - r), r, 180)):
-        for i in range(segs):
+    for k, (ccx, ccz, a0) in enumerate(corners):
+        for i in range(segs + 1):
             a = math.radians(a0 + 90.0 * i / segs)
-            pts.append((cx + r * math.cos(a), cz + r * math.sin(a)))
+            pts.append((ccx + rr * math.cos(a), ccz + rr * math.sin(a)))
+        nx, nz, b0 = corners[(k + 1) % 4]
+        q = (nx + rr * math.cos(math.radians(b0)), nz + rr * math.sin(math.radians(b0)))
+        p0 = pts[-1]
+        cuts = max(1, math.ceil(math.hypot(q[0] - p0[0], q[1] - p0[1]) / FIELD_STEP))
+        pts.extend((p0[0] + (q[0] - p0[0]) * t / cuts, p0[1] + (q[1] - p0[1]) * t / cuts)
+                   for t in range(1, cuts))
     return pts
 
 
-def build_shell():
-    """Loft the rounded-rect profile along Y; caps are the end ngons."""
-    prof = rounded_rect_profile(SHELL_W, SHELL_H, SHELL_R, 6)
-    n = len(prof)
-    y0, y1 = -SHELL_D / 2, SHELL_D / 2
-    bm = bmesh.new()
-    front = [bm.verts.new((x, y0, z)) for x, z in prof]
-    back = [bm.verts.new((x, y1, z)) for x, z in prof]
+def _ccw(poly):
+    area = sum(poly[i][0] * poly[(i + 1) % len(poly)][1]
+               - poly[(i + 1) % len(poly)][0] * poly[i][1] for i in range(len(poly)))
+    return poly if area > 0 else poly[::-1]
+
+
+def _inset_poly(poly, d):
+    """Convex CCW polygon with every edge moved inward by d."""
+    n = len(poly)
+    lines = []
+    for i in range(n):
+        p, q = Vector(poly[i]), Vector(poly[(i + 1) % n])
+        t = (q - p).normalized()
+        lines.append((p + Vector((-t.y, t.x)) * d, t))
+    out = []
+    for i in range(n):
+        (p1, t1), (p2, t2) = lines[i - 1], lines[i]
+        den = t1.x * t2.y - t1.y * t2.x
+        s = ((p2.x - p1.x) * t2.y - (p2.y - p1.y) * t2.x) / den
+        out.append(p1 + t1 * s)
+    return out
+
+
+def rounded_outline(tri, off, r):
+    """Arc samples [(core point, angle)] of a convex polygon inset by `off`
+    with its corners rounded to radius r. Sampling a smaller radius with
+    the same list gives a concentric outline (a 45-deg wall or a flat ring
+    between them)."""
+    core = _inset_poly(_ccw(tri), off + r)
+    n = len(core)
+    samples = []
+    for i in range(n):
+        t_in = (core[i] - core[i - 1]).normalized()
+        t_out = (core[(i + 1) % n] - core[i]).normalized()
+        a0 = math.atan2(-t_in.x, t_in.y)          # outward normal, incoming edge
+        a1 = math.atan2(-t_out.x, t_out.y)        # outward normal, outgoing edge
+        sweep = (a1 - a0) % (2.0 * math.pi)
+        k = max(1, math.ceil(math.degrees(sweep) / ARC_STEP))
+        samples.extend((core[i], a0 + sweep * j / k) for j in range(k + 1))
+        run = core[(i + 1) % n] - core[i]
+        cuts = max(1, math.ceil(run.length / FIELD_STEP))
+        samples.extend((core[i] + run * (t / cuts), a1) for t in range(1, cuts))
+    return samples
+
+
+def panel_triangles():
+    """The four stamped panels; the X is what is left between them."""
+    a = W / 2 - FACE_BORDER - PANEL_MARGIN
+    zt, zb, zc = H - FACE_BORDER - PANEL_MARGIN, FACE_BORDER + PANEL_MARGIN, H / 2
+    return [((-a, zt), (0.0, zc), (a, zt)), ((-a, zb), (a, zb), (0.0, zc)),
+            ((-a, zt), (-a, zb), (0.0, zc)), ((a, zb), (a, zt), (0.0, zc))]
+
+
+def pressed_face(bm, wl, outline, y0, s):
+    """Front (s=-1) or back (s=+1) face: flat border ring, four raised
+    panels, and a triangle fill of the flat field between them."""
+    inner = [bm.verts.new((x, y0, z)) for x, z in rrect(FACE_BORDER)]
+    n = len(inner)
     for i in range(n):
         j = (i + 1) % n
-        bm.faces.new((front[i], back[i], back[j], front[j]))
-    bm.faces.new(front)
-    bm.faces.new(back)
-    return finish_mesh("Shell", bm)
-
-
-def build_rib(name, p0, p1, face_y, outward):
-    """Trapezoid-section pressed rib from p0 to p1 (x, z), raised off the
-    face plane by `outward` (-1 front, +1 back)."""
-    wb, wt, hgt = 0.09, 0.06, 0.045
-    d = Vector((p1[0] - p0[0], 0.0, p1[1] - p0[1])).normalized()
-    side = Vector((-d.z, 0.0, d.x))
-    up = Vector((0.0, outward, 0.0))
+        bm.faces.new((outline[i], outline[j], inner[j], inner[i]))
+    fill = [bm.edges.get((inner[i], inner[(i + 1) % n])) for i in range(n)]
+    for tri in panel_triangles():
+        samples = rounded_outline(tri, CHANNEL, PANEL_R)
+
+        def ring(r, lift, wear):
+            vs = []
+            for c, a in samples:
+                v = bm.verts.new((c.x + r * math.cos(a), y0 + s * lift, c.y + r * math.sin(a)))
+                v[wl] = wear
+                vs.append(v)
+            return vs
+        base = ring(PANEL_R, 0.0, 0.15)
+        top = ring(PANEL_R - PRESS_H, PRESS_H, 1.0)
+        top_in = ring(PANEL_R - PRESS_H - 0.022, PRESS_H, 0.0)
+        m = len(base)
+        for i in range(m):
+            j = (i + 1) % m
+            bm.faces.new((base[i], base[j], top[j], top[i]))
+            bm.faces.new((top[i], top[j], top_in[j], top_in[i]))
+        bm.faces.new(top_in)
+        fill += [bm.edges.get((base[i], base[(i + 1) % m])) for i in range(m)]
+    bmesh.ops.triangle_fill(bm, use_beauty=True, use_dissolve=False,
+                            edges=fill, normal=(0.0, s, 0.0))
+
+
+def build_shell(name):
+    """Side band lofted along Y through wear-ring stations, capped by the
+    two pressed faces. The face/band edge is a true 90-deg break."""
     bm = bmesh.new()
-    ends = []
-    for px, pz in (p0, p1):
-        c = Vector((px, face_y, pz))
-        ends.append([bm.verts.new(c - side * wb), bm.verts.new(c + side * wb),
-                     bm.verts.new(c + side * wt + up * hgt),
-                     bm.verts.new(c - side * wt + up * hgt)])
-    a, b = ends
-    bm.faces.new((a[0], a[1], a[2], a[3]))
-    bm.faces.new((b[1], b[0], b[3], b[2]))
-    bm.faces.new((a[1], b[1], b[2], a[2]))
-    bm.faces.new((a[3], b[3], b[0], a[0]))
-    bm.faces.new((a[0], b[0], b[1], a[1]))
-    bm.faces.new((a[2], b[2], b[3], a[3]))
+    wl = bm.verts.layers.float.new(WEAR)
+    prof = rrect(0.0)
+    n = len(prof)
+    rings = []
+    for y, wear in ((-D / 2, 1.0), (-D / 2 + EDGE_BAND, 0.0), (0.0, 0.0),
+                    (D / 2 - EDGE_BAND, 0.0), (D / 2, 1.0)):
+        ring = [bm.verts.new((x, y, z)) for x, z in prof]
+        for v in ring:
+            v[wl] = wear
+        rings.append(ring)
+    for ra, rb in zip(rings, rings[1:]):
+        for i in range(n):
+            j = (i + 1) % n
+            bm.faces.new((ra[i], ra[j], rb[j], rb[i]))
+    pressed_face(bm, wl, rings[0], -D / 2, -1.0)
+    pressed_face(bm, wl, rings[-1], D / 2, 1.0)
     return finish_mesh(name, bm)
 
 
-def lathe(name, profile, segments):
-    """Spin an (r, z) profile around Z; r == 0 ends become poles."""
+def sweep(name, path, section, axis, closed=False, wear=0.0, matrix=None):
+    """Sweep a closed 2D section (u along the in-plane normal, v along
+    `axis`) down a path lying in the plane normal to `axis`. Open paths are
+    capped with ngons."""
+    axis = Vector(axis)
+    pts = [Vector(p) for p in path]
+    n = len(pts)
     bm = bmesh.new()
+    wl = bm.verts.layers.float.new(WEAR)
+    rings = []
+    for i, p in enumerate(pts):
+        if closed:
+            t = (pts[(i + 1) % n] - pts[i - 1])
+        else:
+            t = pts[min(i + 1, n - 1)] - pts[max(i - 1, 0)]
+        nrm = axis.cross(t.normalized()).normalized()   # outward for CCW paths
+        ring = [bm.verts.new(p + nrm * u + axis * v) for u, v in section]
+        for v in ring:
+            v[wl] = wear
+        rings.append(ring)
+    k = len(section)
+    for i in range(n if closed else n - 1):
+        ra, rb = rings[i], rings[(i + 1) % n]
+        for j in range(k):
+            jj = (j + 1) % k
+            bm.faces.new((ra[j], ra[jj], rb[jj], rb[j]))
+    if not closed:
+        bm.faces.new(rings[0])
+        bm.faces.new(rings[-1][::-1])
+    return finish_mesh(name, bm, matrix)
+
+
+def circle(r, segs=16):
+    return [(r * math.cos(2 * math.pi * i / segs), r * math.sin(2 * math.pi * i / segs))
+            for i in range(segs)]
+
+
+def lathe(name, profile, segments=16, closed=False, wear=None, matrix=None):
+    """Spin an (r, z) profile around Z; r == 0 ends become poles, a closed
+    profile makes a ring. `wear` is an optional per-profile-point list."""
+    wear = list(wear) if wear else [0.0] * len(profile)
+    bm = bmesh.new()
+    wl = bm.verts.layers.float.new(WEAR)
     bot = top = None
-    if profile[0][0] == 0.0:
+    if not closed and profile[0][0] == 0.0:
         bot = bm.verts.new((0.0, 0.0, profile[0][1]))
-        profile = profile[1:]
-    if profile[-1][0] == 0.0:
+        profile, wear = profile[1:], wear[1:]
+    if not closed and profile[-1][0] == 0.0:
         top = bm.verts.new((0.0, 0.0, profile[-1][1]))
-        profile = profile[:-1]
+        profile, wear = profile[:-1], wear[:-1]
     rings = []
     for i in range(segments):
         a = 2.0 * math.pi * i / segments
-        rings.append([bm.verts.new((r * math.cos(a), r * math.sin(a), z))
-                      for r, z in profile])
+        ring = [bm.verts.new((r * math.cos(a), r * math.sin(a), z)) for r, z in profile]
+        for v, w in zip(ring, wear):
+            v[wl] = w
+        rings.append(ring)
+    m = len(profile)
     for i in range(segments):
         j = (i + 1) % segments
-        for k in range(len(profile) - 1):
-            bm.faces.new((rings[i][k], rings[j][k], rings[j][k + 1], rings[i][k + 1]))
+        for k in range(m if closed else m - 1):
+            kk = (k + 1) % m
+            bm.faces.new((rings[i][k], rings[j][k], rings[j][kk], rings[i][kk]))
         if bot is not None:
             bm.faces.new((rings[j][0], rings[i][0], bot))
         if top is not None:
             bm.faces.new((rings[i][-1], rings[j][-1], top))
-    return finish_mesh(name, bm)
+    return finish_mesh(name, bm, matrix)
 
 
-def build_jerry_can():
-    """All parts at world placement; returns {"shell", "rib", "neck", "parts"}."""
-    shell = build_shell()
+def extrude_profile(name, poly, thickness, bevel, matrix=None, wear=0.6):
+    """A flat plate from an (x, z) outline, thickness along Y, every edge
+    chamfered — the cam lever."""
+    bm = bmesh.new()
+    wl = bm.verts.layers.float.new(WEAR)
+    try:
+        front = [bm.verts.new((x, -thickness / 2, z)) for x, z in poly]
+        back = [bm.verts.new((x, thickness / 2, z)) for x, z in poly]
+        n = len(poly)
+        for i in range(n):
+            j = (i + 1) % n
+            bm.faces.new((front[i], front[j], back[j], back[i]))
+        bm.faces.new(front)
+        bm.faces.new(back[::-1])
+        bmesh.ops.recalc_face_normals(bm, faces=bm.faces)
+        bmesh.ops.bevel(bm, geom=list(bm.edges), offset=bevel, segments=1,
+                        affect='EDGES', clamp_overlap=True)
+        for v in bm.verts:
+            v[wl] = wear
+    except Exception:
+        bm.free()
+        raise
+    return finish_mesh(name, bm, matrix)
+
+
+def arc(cx, cz, r, a0, a1, steps):
+    return [(cx + r * math.cos(math.radians(a0 + (a1 - a0) * i / steps)),
+             cz + r * math.sin(math.radians(a0 + (a1 - a0) * i / steps)))
+            for i in range(steps + 1)]
+
+
+def build_jerry_can(suffix=""):
+    """All parts at world placement; returns {"shell", "handle", "neck", "parts"}."""
+    def nm(base):
+        return base + suffix
+
+    shell = build_shell(nm("Shell"))
     parts = [shell]
 
-    ribs = []
-    inset = [(0.46, 0.22), (0.46, 1.58)]
-    specs = [((inset[0], ( -inset[0][0], inset[1][1])), "RibDiagA"),
-             (((-inset[0][0], inset[0][1]), inset[1]), "RibDiagB"),
-             (((0.0, 0.18), (0.0, 1.62)), "RibVert")]
-    for fy, out, tag in ((-SHELL_D / 2, -1.0, "F"), (SHELL_D / 2, 1.0, "B")):
-        for (p0, p1), rn in specs:
-            ribs.append(build_rib(f"{rn}{tag}", p0, p1, fy, out))
-    parts.extend(ribs)
-
-    neck = lathe("Neck", [(0.0, 0.0), (0.21, 0.0), (0.21, 0.05), (0.175, 0.07),
-                          (0.165, 0.10), (0.165, 0.16), (0.185, 0.17),
-                          (0.185, 0.20), (0.165, 0.21), (0.165, 0.24), (0.0, 0.24)], 16)
-    neck.location = (0.42, -0.12, 1.75)
-    neck.rotation_euler = (math.radians(-8.0), 0.0, 0.0)
-    cap = lathe("Cap", [(0.0, 0.0), (0.205, 0.0), (0.205, 0.04), (0.19, 0.05),
-                        (0.19, 0.11), (0.14, 0.14), (0.0, 0.145)], 16)
-    cap.location = (0.42, -0.0866, 1.9877)
-    cap.rotation_euler = (math.radians(-8.0), 0.0, 0.0)
-    parts.extend((neck, cap))
-
-    for i, x in enumerate((-0.28, 0.0, 0.28)):
-        post = lathe(f"Post{i}", [(0.0, 0.0), (0.055, 0.0), (0.055, 0.17), (0.0, 0.17)], 16)
-        post.location = (x, 0.08, 1.79)
-        parts.append(post)
-    grip = lathe("Grip", [(0.0, 0.0), (0.06, 0.0), (0.06, 0.68), (0.0, 0.68)], 16)
-    grip.rotation_euler = (0.0, math.radians(90.0), 0.0)
-    grip.location = (-0.34, 0.08, 1.96)
-    parts.append(grip)
-
-    return {"shell": shell, "rib": ribs[0], "neck": neck, "parts": parts}
+    # weld seam: a chamfered bead swept round the side band at mid-depth
+    bead = [(-0.012, -0.028), (0.010, -0.028), (0.021, -0.012),
+            (0.021, 0.012), (0.010, 0.028), (-0.012, 0.028)]
+    seam_path = [(x, 0.0, z) for x, z in rrect(0.0)]
+    parts.append(sweep(nm("WeldSeam"), seam_path, bead, (0.0, 1.0, 0.0),
+                       closed=True, wear=0.7))
+
+    # triple carry handle: one bent tube over two legs, a centre post, and
+    # three welded feet on the shell top
+    x0, xm, x1 = HANDLE_X
+    rb, zb = 0.09, H - 0.03
+    hp = ([(x0, zb), (x0, HANDLE_TOP - rb)]
+          + arc(x0 + rb, HANDLE_TOP - rb, rb, 180, 90, 4)[1:]
+          + arc(x1 - rb, HANDLE_TOP - rb, rb, 90, 0, 4) + [(x1, zb)])
+    handle = sweep(nm("Handle"), [(x, HANDLE_Y, z) for x, z in hp], circle(0.042),
+                   (0.0, 1.0, 0.0), wear=0.45)
+    parts.append(handle)
+    parts.append(sweep(nm("HandlePost"), [(xm, HANDLE_Y, zb), (xm, HANDLE_Y, HANDLE_TOP)],
+                       circle(0.036), (0.0, 1.0, 0.0), wear=0.3))
+    foot = [(0.0, -0.02), (0.085, -0.02), (0.085, 0.006), (0.066, 0.025), (0.0, 0.025)]
+    for i, x in enumerate(HANDLE_X):
+        parts.append(lathe(nm(f"HandleFoot{i}"), foot, 16, wear=(0, 0, 1, 0.6, 0),
+                           matrix=Matrix.Translation((x, HANDLE_Y, H))))
+
+    # spout assembly, built on a local +Z axis and tilted out over the corner
+    sm = (Matrix.Translation((SPOUT_AT[0], SPOUT_AT[1], H))
+          @ Matrix.Rotation(math.radians(SPOUT_TILT), 4, 'Y'))
+    neck = lathe(nm("Neck"), [(0.0, -0.06), (0.19, -0.06), (0.19, 0.02), (0.15, 0.06),
+                              (0.15, 0.16), (0.165, 0.175), (0.165, 0.20), (0.15, 0.215),
+                              (0.15, 0.22), (0.0, 0.22)], 16,
+                 wear=(0, 0, 1, 0.3, 0, 0.3, 1, 0.3, 0, 0), matrix=sm)
+    parts.append(neck)
+    parts.append(lathe(nm("Seal"), [(0.13, 0.215), (0.188, 0.215), (0.198, 0.225),
+                                    (0.198, 0.25), (0.188, 0.26), (0.13, 0.26)],
+                       16, closed=True, matrix=sm))
+    # cap: vertical skirt, then a dome in 22-deg steps (smooth by angle)
+    cap_prof = [(0.0, 0.26), (0.205, 0.26), (0.205, 0.30), (0.190, 0.337),
+                (0.155, 0.373), (0.091, 0.402), (0.0, 0.405)]
+    parts.append(lathe(nm("Cap"), cap_prof, 16, wear=(0, 0.5, 0.9, 0.3, 0, 0, 0),
+                       matrix=sm))
+    lever = [(0.25, 0.27), (0.27, 0.31), (0.25, 0.36), (0.18, 0.43), (0.05, 0.445),
+             (-0.24, 0.445), (-0.30, 0.43), (-0.30, 0.40), (-0.22, 0.39), (0.04, 0.41),
+             (0.15, 0.395), (0.20, 0.33), (0.20, 0.29)]
+    parts.append(extrude_profile(nm("CamLever"), lever, 0.08, 0.008, matrix=sm))
+    parts.append(lathe(nm("Hinge"), [(0.0, -0.07), (0.035, -0.07), (0.035, 0.07), (0.0, 0.07)],
+                       16, matrix=sm @ Matrix.Translation((0.22, 0.0, 0.30))
+                       @ Matrix.Rotation(math.radians(90), 4, 'X')))
+    parts.append(lathe(nm("LockPin"), [(0.0, -0.075), (0.024, -0.075), (0.024, 0.05),
+                                       (0.04, 0.05), (0.04, 0.075), (0.0, 0.075)],
+                       16, wear=(0, 0, 0, 1, 1, 0),
+                       matrix=sm @ Matrix.Translation((-0.26, 0.0, 0.42))
+                       @ Matrix.Rotation(math.radians(-90), 4, 'X')))
+
+    return {"shell": shell, "handle": handle, "neck": neck, "parts": parts}
 
 
 # ---------------------------------------------------------------------------
@@ -346,13 +568,37 @@ def check_normal_welds(obj):
 
 def check_custom_normals_roundtrip(obj):
     """Per-loop custom normals survive depsgraph evaluation. Tolerance is the
-    int16 storage quantization, measured 7.5e-05 on both versions."""
+    int16 storage quantization, measured 7.5e-05 on both versions.
+
+    Each corner requests its face normal tilted CUSTOM_TILT toward the
+    corner bisector — a distinct normal per corner, as a weighted-normal or
+    bevel-softening pass writes. Blender's encoder (the lnor-space
+    LNOR_SPACE_TRIGO_THRESHOLD, dot > 1 - 1e-4, ~0.81 deg) is not storage
+    precision and must stay out of the measurement: requested normals in one
+    fan closer than that are MERGED to their average (a pattern stepping
+    ~7e-4 rad per loop over 4.5k loops measured 1.4e-02), and an in-plane
+    angle from the space's reference edge under it is SNAPPED to zero (an
+    arbitrary-direction pattern put 13 of 4.5k corners there, 9.1e-03).
+    Aimed at the bisector, the in-plane angle is half the corner — never
+    near zero on this mesh — so the round-trip isolates quantization."""
     me = obj.data
     n = len(me.loops)
-    custom = []
-    for i in range(n):
-        a = 2.0 * math.pi * i / n
-        custom.append(Vector((0.5 * math.cos(a), 0.5 * math.sin(a), 0.85)).normalized())
+    custom = [None] * n
+    co = [v.co for v in me.vertices]
+    for poly in me.polygons:
+        fn = poly.normal
+        vs = poly.vertices
+        k = len(vs)
+        for j in range(k):
+            c = co[vs[j]]
+            e_prev = (co[vs[j - 1]] - c).normalized()
+            e_next = (co[vs[(j + 1) % k]] - c).normalized()
+            bis = e_prev + e_next
+            bis -= fn * bis.dot(fn)
+            if bis.length < 1e-6:           # straight corner: perpendicular in-plane
+                bis = fn.cross(e_next)
+            custom[poly.loop_start + j] = (fn * math.cos(CUSTOM_TILT)
+                                           + bis.normalized() * math.sin(CUSTOM_TILT))
     me.normals_split_custom_set(custom)
     if not me.has_custom_normals:
         print("ERROR: has_custom_normals False after normals_split_custom_set — "
@@ -416,68 +662,168 @@ def check_legacy_operator():
 
 
 # ---------------------------------------------------------------------------
-# Render: the same can three ways — flat (faceting), smooth-everywhere (the
-# smeared AI bug), by-angle (the contract). Failure modes flank the truth.
+# Render: three fresh builds of the same can, one per shading treatment —
+# flat (every facet shows), smooth-everywhere (the shade_smooth-and-forget
+# AI habit: flat faces smear into gradients, pressed panels go pillowy),
+# and by-angle (the contract). Failure modes flank the truth.
 # ---------------------------------------------------------------------------
 
 def eevee_engine_id():
     return 'BLENDER_EEVEE' if bpy.app.version >= (5, 0, 0) else 'BLENDER_EEVEE_NEXT'
 
 
-def make_material(name, color, metallic, roughness):
+def make_material(name, color, metallic, roughness, coat=0.0):
     mat = bpy.data.materials.new(name)
     mat.use_nodes = True
     bsdf = mat.node_tree.nodes["Principled BSDF"]
     bsdf.inputs["Base Color"].default_value = (*color, 1.0)
     bsdf.inputs["Metallic"].default_value = metallic
     bsdf.inputs["Roughness"].default_value = roughness
+    if coat:
+        bsdf.inputs["Coat Weight"].default_value = coat
+        bsdf.inputs["Coat Roughness"].default_value = 0.12
     return mat
 
 
-def variant_meshes(parts, mode):
-    """Fresh mesh copies with one shading treatment applied."""
-    out = []
+def make_painted_steel(name, paint, steel):
+    """Semi-gloss paint over steel, chipped where the `wear` attribute says
+    an edge is exposed. Glossy enough (coat) that a highlight exposes every
+    normal discontinuity — matte paint would hide the very differences this
+    render exists to show."""
+    mat = bpy.data.materials.new(name)
+    mat.use_nodes = True
+    nt = mat.node_tree
+    nodes, links = nt.nodes, nt.links
+    out = nodes["Material Output"]
+    paint_bsdf = nodes["Principled BSDF"]
+    paint_bsdf.inputs["Base Color"].default_value = (*paint, 1.0)
+    paint_bsdf.inputs["Metallic"].default_value = 0.0
+    paint_bsdf.inputs["Coat Weight"].default_value = 0.35
+    paint_bsdf.inputs["Coat Roughness"].default_value = 0.18
+    steel_bsdf = nodes.new("ShaderNodeBsdfPrincipled")
+    steel_bsdf.inputs["Base Color"].default_value = (*steel, 1.0)
+    steel_bsdf.inputs["Metallic"].default_value = 1.0
+    steel_bsdf.inputs["Roughness"].default_value = 0.32
+
+    coord = nodes.new("ShaderNodeTexCoord")
+    chips = nodes.new("ShaderNodeTexNoise")
+    chips.inputs["Scale"].default_value = 18.0
+    chips.inputs["Detail"].default_value = 6.0
+    links.new(coord.outputs["Object"], chips.inputs["Vector"])
+    mottle = nodes.new("ShaderNodeTexNoise")
+    mottle.inputs["Scale"].default_value = 4.0
+    links.new(coord.outputs["Object"], mottle.inputs["Vector"])
+    rough = nodes.new("ShaderNodeMapRange")
+    rough.inputs["To Min"].default_value = 0.30
+    rough.inputs["To Max"].default_value = 0.46
+    links.new(mottle.outputs["Fac"], rough.inputs["Value"])
+    links.new(rough.outputs["Result"], paint_bsdf.inputs["Roughness"])
+
+    wear = nodes.new("ShaderNodeAttribute")
+    wear.attribute_name = WEAR
+    # chip = wear + (noise - 0.5) * 1.6, thresholded to a crisp paint edge
+    jitter = nodes.new("ShaderNodeMath")
+    jitter.operation = 'MULTIPLY_ADD'
+    jitter.inputs[1].default_value = 1.6
+    jitter.inputs[2].default_value = -0.8
+    links.new(chips.outputs["Fac"], jitter.inputs[0])
+    total = nodes.new("ShaderNodeMath")
+    total.operation = 'ADD'
+    links.new(wear.outputs["Fac"], total.inputs[0])
+    links.new(jitter.outputs["Value"], total.inputs[1])
+    mask = nodes.new("ShaderNodeMapRange")
+    mask.inputs["From Min"].default_value = 0.86
+    mask.inputs["From Max"].default_value = 0.92
+    links.new(total.outputs["Value"], mask.inputs["Value"])
+
+    mix = nodes.new("ShaderNodeMixShader")
+    links.new(mask.outputs["Result"], mix.inputs["Fac"])
+    links.new(paint_bsdf.outputs["BSDF"], mix.inputs[1])
+    links.new(steel_bsdf.outputs["BSDF"], mix.inputs[2])
+    links.new(mix.outputs["Shader"], out.inputs["Surface"])
+    return mat
+
+
+PART_MATERIAL = {"CamLever": "steel", "Hinge": "steel", "LockPin": "steel", "Seal": "seal"}
+
+
+def shade(parts, mode):
+    """The one variable across the three cans."""
     for o in parts:
-        me = o.data.copy()
-        me.name = f"{o.name}_{mode}"
+        me = o.data
         for p in me.polygons:
             p.use_smooth = mode != "flat"
         if mode == "byangle":
             me.set_sharp_from_angle(angle=ANGLE)
-        dup = bpy.data.objects.new(f"{o.name}_{mode}", me)
-        dup.location = o.location
-        dup.rotation_euler = o.rotation_euler
-        bpy.context.collection.objects.link(dup)
-        out.append(dup)
-    return out
+
+
+def sharp_edge_overlay(parts, name, radius=0.0026):
+    """Thin tubes along every edge the `sharp_edge` attribute marks — the
+    contract's own output drawn onto the by-angle can, read back from the
+    mesh rather than recomputed."""
+    bm = bmesh.new()
+    try:
+        for o in parts:
+            me = o.data
+            attr = me.attributes.get("sharp_edge")
+            if attr is None:
+                continue
+            for e, d in zip(me.edges, attr.data):
+                if not d.value:
+                    continue
+                a, b = (me.vertices[i].co for i in e.vertices)
+                t = (b - a).normalized()
+                u = t.orthogonal().normalized()
+                w = t.cross(u)
+                ring = []
+                for k in range(4):
+                    ang = math.pi * 0.5 * k
+                    off = (u * math.cos(ang) + w * math.sin(ang)) * radius
+                    ring.append((bm.verts.new(a + off), bm.verts.new(b + off)))
+                for k in range(4):
+                    (a0, b0), (a1, b1) = ring[k], ring[(k + 1) % 4]
+                    bm.faces.new((a0, a1, b1, b0))
+        me = bpy.data.meshes.new(name)
+        bm.to_mesh(me)
+    finally:
+        bm.free()
+    obj = bpy.data.objects.new(name, me)
+    bpy.context.collection.objects.link(obj)
+    return obj
 
 
 def render_still(can, path, engine):
     scene = bpy.context.scene
-    # semi-gloss painted steel: rough enough to read as paint, glossy enough
-    # that a highlight exposes every normal discontinuity — matte would hide
-    # the very shading differences this render exists to show
-    steel = make_material("OliveDrab", (0.30, 0.345, 0.13), 0.8, 0.26)
-    accent = make_material("FuelMarker", (0.55, 0.06, 0.03), 0.3, 0.30)
-
-    # the checked base can IS the by-angle variant; the two failure modes are
-    # mesh copies with their own shading, no materials yet
-    variants = []
-    for mode, x in (("flat", -1.5), ("smooth", 0.0), ("byangle", 1.5)):
-        objs = variant_meshes(can["parts"], mode)
-        for o in objs:
-            o.location.x += x
-            o.rotation_euler.z += math.radians(-10.0)  # uniform yaw, fronts to camera
-            o.data.materials.append(steel)
-            if o.name.startswith("Cap"):
-                o.data.materials.append(accent)
-                for p in o.data.polygons:  # cap rim ring in the marker red
-                    if p.center.z < 0.045:
-                        p.material_index = 1
-        variants.append(objs)
-    # hide the checked originals: the byangle variant re-shows the same data
+    mats = {
+        "paint": make_painted_steel("OlivePaint", (0.085, 0.115, 0.030), (0.30, 0.30, 0.29)),
+        "steel": make_material("BareSteel", (0.42, 0.41, 0.39), 1.0, 0.34),
+        "seal": make_material("SealRed", (0.62, 0.035, 0.02), 0.0, 0.42),
+    }
+
+    # the checked can stays hidden; the gallery shows three fresh builds
     for o in can["parts"]:
         o.hide_render = True
+    variants = {}
+    for mode, x in (("flat", -1.62), ("smooth", 0.0), ("byangle", 1.62)):
+        built = build_jerry_can("_" + mode)["parts"]
+        shade(built, mode)
+        for o in built:
+            base = o.name[: -len(mode) - 1].rstrip("0123456789")
+            o.data.materials.append(mats[PART_MATERIAL.get(base, "paint")])
+            o.location = (x, 0.0, 0.0)
+            o.rotation_euler = (0.0, 0.0, math.radians(-30.0))
+        variants[mode] = built
+    hero = [o for objs in variants.values() for o in objs]
+    edges = sharp_edge_overlay(variants["byangle"], "SharpEdgeOverlay")
+    glow = bpy.data.materials.new("SharpEdgeGlow")
+    glow.use_nodes = True
+    gb = glow.node_tree.nodes["Principled BSDF"]
+    gb.inputs["Base Color"].default_value = (0.35, 0.85, 1.0, 1.0)
+    gb.inputs["Emission Color"].default_value = (0.35, 0.85, 1.0, 1.0)
+    gb.inputs["Emission Strength"].default_value = 1.0
+    edges.data.materials.append(glow)
+    edges.location = variants["byangle"][0].location
+    edges.rotation_euler = variants["byangle"][0].rotation_euler
 
     floor_me = bpy.data.meshes.new("Floor")
     bm = bmesh.new()
@@ -486,12 +832,11 @@ def render_still(can, path, engine):
         bm.to_mesh(floor_me)
     finally:
         bm.free()
-    fmat = make_material("Studio", (0.03, 0.032, 0.037), 0.0, 0.7)
-    floor_me.materials.append(fmat)
+    floor_me.materials.append(make_material("Studio", (0.03, 0.032, 0.037), 0.0, 0.7))
     floor = bpy.data.objects.new("Floor", floor_me)
     scene.collection.objects.link(floor)
     wall = bpy.data.objects.new("Wall", floor_me.copy())
-    wall.location = (0.0, 11.0, 0.0)
+    wall.location = (0.0, 9.0, 0.0)
     wall.rotation_euler = (math.radians(90), 0.0, 0.0)
     scene.collection.objects.link(wall)
 
@@ -500,40 +845,37 @@ def render_still(can, path, engine):
     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):
+    def light(name, loc, energy, size, col, rot, size_y=None):
         ld = bpy.data.lights.new(name, 'AREA')
-        ld.energy = energy; ld.size = size; ld.color = col
+        ld.energy = energy
+        ld.color = col
+        ld.size = size
+        if size_y is not None:
+            ld.shape = 'RECTANGLE'
+            ld.size_y = size_y
         ob = bpy.data.objects.new(name, ld)
         ob.location = loc
         ob.rotation_euler = tuple(math.radians(a) for a in rot)
         scene.collection.objects.link(ob)
+        return ob
 
     # key/fill/rim/wedge per docs/VISUAL-STYLE.md
-    light("Key", (-4.0, -5.0, 6.0), 520.0, 4.5, (1.0, 0.96, 0.9), (50, 0, -38))
-    light("Fill", (5.5, -3.5, 2.5), 150.0, 9.0, (0.75, 0.85, 1.0), (65, 0, 55))
-    light("Rim", (1.5, 4.5, 4.0), 340.0, 3.0, (0.6, 0.78, 1.0), (-58, 0, 170))
-    light("Wedge", (2.5, 5.5, 4.0), 400.0, 6.0, (1.0, 0.76, 0.5), (-68, 0, 190))
-    # the shading audit light: a tall strip whose reflection runs down each
-    # can face — it stair-steps on flat shading, warps at the rim on
-    # smooth-everything, and stays straight with crisp edges on by-angle
-    ld = bpy.data.lights.new("Strip", 'AREA')
-    ld.energy = 400.0
-    ld.shape = 'RECTANGLE'
-    ld.size = 1.35
-    ld.size_y = 8.0
-    ld.color = (0.9, 0.95, 1.0)
-    strip = bpy.data.objects.new("Strip", ld)
-    strip.location = (-3.5, -4.5, 3.2)
-    strip.rotation_euler = (math.radians(60), 0.0, math.radians(-30))
-    scene.collection.objects.link(strip)
+    light("Key", (-4.0, -5.0, 6.0), 560.0, 4.5, (1.0, 0.96, 0.9), (50, 0, -38))
+    light("Fill", (5.5, -3.5, 2.5), 110.0, 9.0, (0.75, 0.85, 1.0), (65, 0, 55))
+    light("Rim", (1.5, 4.5, 4.0), 320.0, 3.0, (0.6, 0.78, 1.0), (-58, 0, 170))
+    light("Wedge", (1.2, 6.2, 3.0), 500.0, 6.0, (1.0, 0.76, 0.5), (70, 0, 12))
+    # the shading audit light: a tall narrow strip low on the camera's left.
+    # The pressed faces mirror it: a straight band broken cleanly at every
+    # crease on by-angle, stepped on flat, bent into a smear on smooth.
+    light("Strip", (-5.2, -5.6, 1.4), 320.0, 0.6, (0.92, 0.96, 1.0), (90, 0, -42), size_y=6.0)
 
     cam_data = bpy.data.cameras.new("Cam")
     cam_data.lens = 50.0
     cam = bpy.data.objects.new("Cam", cam_data)
-    cam.location = (1.9, -7.2, 2.6)
+    cam.location = (0.77, -8.0, 2.8)
     scene.collection.objects.link(cam)
     target = bpy.data.objects.new("Aim", None)
-    target.location = (0.0, 0.0, 1.05)
+    target.location = (0.0, 0.0, 1.08)
     scene.collection.objects.link(target)
     con = cam.constraints.new('TRACK_TO')
     con.target = target
@@ -553,8 +895,21 @@ def light(name, loc, energy, size, col, rot):
     scene.render.filepath = path
     # AgX would flatten the olive drab toward mud (docs/VISUAL-STYLE.md)
     scene.view_settings.view_transform = 'Standard'
+    bpy.context.view_layer.update()
+
+    fcode = gallery_framing.check_framing(scene, cam, hero=hero, elements=hero + [edges],
+                                          stage=[floor, wall])
+    if fcode:
+        return fcode
+    aqcode = gallery_asset_quality.check_asset_quality(scene, cam, hero=variants["byangle"],
+                                                       stage=[floor, wall])
+    if aqcode:
+        return aqcode
     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 9
+    return 0
 
 
 def main():
@@ -572,7 +927,7 @@ def main():
 
     for step in (lambda: check_api_surface(can["shell"].data),
                  lambda: check_by_angle(
-                     [can["shell"], can["rib"], can["neck"]],
+                     [can["shell"], can["handle"], can["neck"]],
                      mismatch_angle=args.mismatch_angle),
                  lambda: check_normal_welds(can["shell"]),
                  lambda: check_custom_normals_roundtrip(can["shell"]),
@@ -582,9 +937,9 @@ def main():
             return code
 
     if args.output:
-        if not render_still(can, os.path.abspath(args.output), args.engine):
-            print("ERROR: render produced no file", file=sys.stderr)
-            return 9
+        code = render_still(can, os.path.abspath(args.output), args.engine)
+        if code:
+            return code
         print(f"rendered still {args.output}")
 
     print("custom-normals-shade OK")
diff --git a/examples/custom-normals-shade/preview.webp b/examples/custom-normals-shade/preview.webp
index 8953e5f5..1a3ea5f8 100644
Binary files a/examples/custom-normals-shade/preview.webp and b/examples/custom-normals-shade/preview.webp differ
diff --git a/examples/gallery.json b/examples/gallery.json
index 412728dc..ca947b48 100644
--- a/examples/gallery.json
+++ b/examples/gallery.json
@@ -446,9 +446,9 @@
     {
       "name": "custom-normals-shade",
       "dir": "examples/custom-normals-shade",
-      "teaches": "A jerry can prop shaded three ways to prove the post-4.1 shading contract: hard edges are mesh data, landing exactly where the dihedral crosses. Face smooth flags plus a sharp_edge attribute, verified against an independently recomputed dihedral test, and per-loop custom normals surviving depsgraph evaluation within their int16 storage quantization (1.407e-04, not float-exact).",
-      "alt": "Three olive jerry cans with embossed X ribs, shaded flat, smooth and smooth-by-angle.",
-      "witnessesFix": "use_auto_smooth, use_custom_normals and calc_normals are AttributeError on BOTH 4.5 LTS and 5.1 - AI code still emits them. The legacy shade_auto_smooth operator CANCELS headless on 4.5 (asset load never finishes; mesh untouched; no exception) while 5.1 FINISHES with the Smooth by Angle NODES modifier. By-angle sharp sets match the independent dihedral recompute exactly (188 of 388 edges over 3 meshes).",
+      "teaches": "A jerry can prop shaded three ways to prove the post-4.1 shading contract: hard edges are mesh data, landing exactly where the dihedral crosses. Face smooth flags plus a sharp_edge attribute, verified against an independently recomputed dihedral test, and per-loop custom normals surviving depsgraph evaluation within their int16 storage quantization (3.904e-05 over 8196 loops, not float-exact).",
+      "alt": "Three olive jerry cans with X-pressed panels, triple handles and red-sealed spouts: faceted flat, glossy-smeared smooth-everywhere, and crisp by-angle with its sharp edges traced in thin cyan lines.",
+      "witnessesFix": "use_auto_smooth, use_custom_normals and calc_normals are AttributeError on BOTH 4.5 LTS and 5.1 - AI code still emits them. The legacy shade_auto_smooth operator CANCELS headless on 4.5 (asset load never finishes; mesh untouched; no exception) while 5.1 FINISHES with the Smooth by Angle NODES modifier. By-angle sharp sets match the independent dihedral recompute exactly (1304 of 4738 edges over 3 meshes).",
       "hero": "docs/gallery/assets/custom-normals-shade-hero.webp",
       "preview": "examples/custom-normals-shade/preview.webp",
       "tags": [