diff --git a/README.md b/README.md
index e362b102..8af38fbb 100644
--- a/README.md
+++ b/README.md
@@ -440,15 +440,16 @@ semver on LTS builds (`"4.5.11 LTS"`), and that a Mesh reference dies at
 </tr>
 <tr>
 <td width="46%" valign="middle">
-<a href="examples/depsgraph-export/"><img src="examples/depsgraph-export/preview.webp" alt="Depsgraph-evaluated export: a teal base cube beside the smooth teal sphere of its subdivision-surface evaluated form - one shared material, two silhouettes - on a dark studio floor with a warm light pool behind" /></a>
+<a href="examples/depsgraph-export/"><img src="examples/depsgraph-export/preview.webp" alt="Depsgraph-evaluated export: the sparse control cage of a game controller drawn as orange wire and vertex beads over faint blue facets, beside the smooth subdivided cobalt controller with sticks, d-pad and colored face buttons that the OBJ export contains, on a dark studio floor with a warm light pool behind" /></a>
 </td>
 <td valign="middle">
 
 ### [depsgraph-export](examples/depsgraph-export/)
 
-A depsgraph-evaluated export — builds a cube with `SUBSURF`, measures the evaluated mesh via
-`evaluated_get().to_mesh()` / `to_mesh_clear()`, and asserts `wm.obj_export` ships the
-modifier-applied geometry (exported vertex count == evaluated > base).
+A depsgraph-evaluated export — builds a game controller whose shell is a 90-vertex quad cage
+under `SUBSURF`, measures every mesh via `evaluated_get().to_mesh()` / `to_mesh_clear()`,
+asserts the evaluated shell matches the Catmull-Clark closed form (1,410 vertices), and asserts
+`wm.obj_export` ships the modifier-applied geometry (exported vertex count == evaluated > base).
 
 </td>
 </tr>
diff --git a/docs/gallery/asset-sheets/depsgraph-export.webp b/docs/gallery/asset-sheets/depsgraph-export.webp
new file mode 100644
index 00000000..8856eea8
Binary files /dev/null and b/docs/gallery/asset-sheets/depsgraph-export.webp differ
diff --git a/docs/gallery/assets/depsgraph-export-hero.webp b/docs/gallery/assets/depsgraph-export-hero.webp
index 80b0308b..9abfbbf1 100644
Binary files a/docs/gallery/assets/depsgraph-export-hero.webp and b/docs/gallery/assets/depsgraph-export-hero.webp differ
diff --git a/docs/gallery/contact-sheets/depsgraph-export-contact-sheet.webp b/docs/gallery/contact-sheets/depsgraph-export-contact-sheet.webp
index 448cb796..110f47bf 100644
Binary files a/docs/gallery/contact-sheets/depsgraph-export-contact-sheet.webp and b/docs/gallery/contact-sheets/depsgraph-export-contact-sheet.webp differ
diff --git a/docs/gallery/depsgraph-export/index.html b/docs/gallery/depsgraph-export/index.html
index b661f7da..8c5c77d8 100644
--- a/docs/gallery/depsgraph-export/index.html
+++ b/docs/gallery/depsgraph-export/index.html
@@ -16,13 +16,13 @@
   <meta property="og:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/depsgraph-export-hero.webp" />
   <meta property="og:image:width" content="1280" />
   <meta property="og:image:height" content="720" />
-  <meta property="og:image:alt" content="A teal cube outlined by its twelve edges beside a faceted teal sphere covered in a dense pale wire grid, on a dark studio floor." />
+  <meta property="og:image:alt" content="A game controller&#x27;s sparse control cage in orange wire and vertex beads beside the smooth subdivided cobalt controller with sticks and colored buttons, on a dark studio floor." />
   <meta property="og:site_name" content="Blender Developer Tools" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="depsgraph-export — Examples — Blender Developer Tools" />
   <meta name="twitter:description" content="The depsgraph lifetime contract — evaluated_get().to_mesh() paired with to_mesh_clear() — measured against an OBJ export of the same object." />
   <meta name="twitter:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/depsgraph-export-hero.webp" />
-  <meta name="twitter:image:alt" content="A teal cube outlined by its twelve edges beside a faceted teal sphere covered in a dense pale wire grid, on a dark studio floor." />
+  <meta name="twitter:image:alt" content="A game controller&#x27;s sparse control cage in orange wire and vertex beads beside the smooth subdivided cobalt controller with sticks and colored buttons, on a dark studio floor." />
   <style>
     /* fonts are deployed by the landing build (docs/fonts/) */
     @font-face { font-family: 'Barlow Condensed'; font-weight: 600; font-display: swap;
@@ -268,18 +268,22 @@ <h1>depsgraph-export</h1>
     <p>The depsgraph lifetime contract — evaluated_get().to_mesh() paired with to_mesh_clear() — measured against an OBJ export of the same object.</p>
   </header>
   <main id="main">
-    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: A teal cube outlined by its twelve edges beside a faceted teal sphere covered in a dense pale wire grid, on a dark studio floor.">
-      <img src="../assets/depsgraph-export-hero.webp" alt="A teal cube outlined by its twelve edges beside a faceted teal sphere covered in a dense pale wire grid, on a dark studio floor." width="1280" height="720" />
+    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: A game controller&#x27;s sparse control cage in orange wire and vertex beads beside the smooth subdivided cobalt controller with sticks and colored buttons, on a dark studio floor.">
+      <img src="../assets/depsgraph-export-hero.webp" alt="A game controller&#x27;s sparse control cage in orange wire and vertex beads beside the smooth subdivided cobalt controller with sticks and colored buttons, on a dark studio floor." 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> Exports ship evaluated geometry: the exported vertex count equals the subsurf-applied count and is strictly greater than the base mesh.</div>
+    <div class="callout"><span class="tag">witnesses</span> Exports ship evaluated geometry: the controller shell subdivides to exactly its Catmull-Clark closed form, and the exported vertex count equals the subsurf-applied count, strictly greater than the base mesh.</div>
     <div class="runline">
       <pre id="runCmd">blender --background --python examples/depsgraph-export/depsgraph_export.py --</pre>
       <button class="copy-btn" id="copyRun" type="button">Copy</button>
     </div>
     <section class="detail-section md">
-<p>A runnable example that proves <strong>modifiers actually ship in exports</strong> and demonstrates the <a href="https://github.com/TMHSDigital/Blender-Developer-Tools/tree/main/skills/depsgraph-and-evaluated-data/SKILL.md"><code>depsgraph-and-evaluated-data</code></a> lifetime contract. It builds a cube with a SUBSURF modifier, measures the evaluated mesh via <code>evaluated_get().to_mesh()</code> (paired with <code>to_mesh_clear()</code>), exports through <code>wm.obj_export</code>, and asserts the exported vertex count equals the <strong>evaluated</strong> (modifier-applied) count and is strictly greater than the base mesh.</p>
+<p>A runnable example that proves <strong>modifiers actually ship in exports</strong> and demonstrates the <a href="https://github.com/TMHSDigital/Blender-Developer-Tools/tree/main/skills/depsgraph-and-evaluated-data/SKILL.md"><code>depsgraph-and-evaluated-data</code></a> lifetime contract. It builds a game controller whose shell is a sparse quad control cage (90 vertices) under a level-2 <code>SUBSURF</code> modifier, with the sticks, d-pad, face buttons and bumpers modeled as ordinary parts parented to it. It measures every mesh via <code>evaluated_get().to_mesh()</code> (each paired with <code>to_mesh_clear()</code>), exports the scene through <code>wm.obj_export</code>, and asserts:</p>
+<ul><li>the evaluated shell has exactly the vertex count the Catmull-Clark closed form predicts from the cage&#x27;s own topology — per level <code>V&#x27; = V + E + F</code>, <code>E&#x27; = 2E + S</code>, <code>F&#x27; = S</code> (S = face corners) — which for this cage (V=90, E=176, F=88, S=352) is <strong>1,410</strong>;</li><li>the exported OBJ vertex count equals the summed <strong>evaluated</strong> counts of every mesh (3,666), not the summed base counts (2,346).</li></ul>
 <p><strong>What it witnesses:</strong> the <code>evaluated_get</code> → <code>to_mesh</code> → <code>to_mesh_clear</code> contract, and that <code>wm.obj_export</code> writes the depsgraph-evaluated geometry (so modifiers are baked into the export) rather than the unmodified base mesh.</p>
+<h2>The render</h2>
+<p>Left: the shell datablock as the <code>.blend</code> stores it — its 90-vertex control cage drawn as orange wire with a bead on every vertex, over faint blue facets. Right: the same object as the depsgraph evaluates it and the OBJ contains it — the smooth subdivided cobalt controller with its controls. If the export shipped the base mesh, the right-hand piece would be the blocky cage on the left.</p>
+<p>Both pieces lean toward the camera on low satin display stands (render-only, added after the check and export have run).</p>
 <h2>Run</h2>
 <pre><code># Cheap correctness check (writes an OBJ to a temp path, asserts the counts) — the CI check:
 blender --background --python depsgraph_export.py --
@@ -287,18 +291,18 @@ <h2>Run</h2>
 # Falsifier: apply_modifiers=False. Must exit non-zero (export ≠ evaluated).
 blender --background --python depsgraph_export.py -- --unevaluated
 
-# Also render a still of base vs evaluated (EEVEE on a GPU host; cycles on GPU-less hosts):
+# Also render a still of cage vs evaluated (EEVEE on a GPU host; cycles on GPU-less hosts):
 blender --background --python depsgraph_export.py -- --output depsgraph.png
 blender --background --python depsgraph_export.py -- --output depsgraph.png --engine cycles
 
 # Write the exported OBJ to a specific path:
 blender --background --python depsgraph_export.py -- --obj exported.obj</code></pre>
 <h2>Exit codes</h2>
-<p>Per-script sequential checks. <code>9</code> is a valid check code; there is no rule against it. <code>10</code> is the shared framing helper.</p>
-<div class="table-wrap"><table><thead><tr><th scope="col">Code</th><th scope="col">Meaning</th></tr></thead><tbody><tr><td>0</td><td>Success</td></tr><tr><td>1</td><td>Uncaught exception (FATAL wrapper)</td></tr><tr><td>2</td><td>argparse / usage</td></tr><tr><td>3</td><td>Evaluated mesh did not apply the modifier</td></tr><tr><td>4</td><td>No OBJ written</td></tr><tr><td>5</td><td>Export vert count ≠ evaluated (<code>--unevaluated</code> lands here)</td></tr><tr><td>6</td><td><code>--output</code> produced no file</td></tr><tr><td>10</td><td>Gallery framing violation</td></tr></tbody></table></div>
+<p>Per-script sequential checks. <code>9</code> is a valid check code; there is no rule against it. <code>10</code> and <code>11</code> are the shared framing and asset-quality helpers.</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>Evaluated shell did not apply the modifier (evaluated count not above the cage)</td></tr><tr><td>4</td><td>No OBJ written</td></tr><tr><td>5</td><td>Export vert count ≠ evaluated (<code>--unevaluated</code> lands here)</td></tr><tr><td>6</td><td><code>--output</code> produced no file</td></tr><tr><td>7</td><td>Evaluated shell count ≠ Catmull-Clark closed form</td></tr><tr><td>10</td><td>Gallery framing violation</td></tr><tr><td>11</td><td>Asset-quality floor violation (render path only)</td></tr></tbody></table></div>
 <p><code>--obj</code> is a path selector, not a falsifier.</p>
 <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>, <code>--obj</code>, or <code>--unevaluated</code>.</p>
-<p>The <code>--output</code> render path additionally measures framing against the Layer 1 band via <code>examples/gallery_framing.py</code> (exit 10 on violation) before writing the still.</p>
+<p>The <code>--output</code> render path additionally measures framing against the Layer 1 band via <code>examples/gallery_framing.py</code> (exit 10) and the asset-quality floors on the shipped controller via <code>examples/gallery_asset_quality.py</code> (exit 11) before writing the still.</p>
     </section>
     <section class="detail-section src">
       <h2>Source</h2>
@@ -309,13 +313,21 @@ <h2>Source</h2>
       <pre><span class="s">&quot;&quot;&quot;Depsgraph-evaluated export — a runnable example.
 
 Witnesses the depsgraph lifetime contract AND that modifiers actually ship in
-exports. Builds a cube with a SUBSURF modifier, measures the evaluated mesh via
-evaluated_get().to_mesh() (paired with to_mesh_clear()), exports through
-wm.obj_export, and asserts the exported vertex count equals the EVALUATED
-(modifier-applied) count and is strictly greater than the base.
+exports. Builds a game controller whose shell is a sparse quad control cage
+under a SUBSURF modifier (the buttons, sticks and bumpers are plain modeled
+parts parented to it), measures every mesh through
+evaluated_get().to_mesh() (each paired with to_mesh_clear()), exports the
+scene through wm.obj_export, and asserts:
+
+- the shell&#x27;s evaluated vertex count equals the Catmull-Clark closed form
+  computed from its own cage topology (V, E, F, face corners) at the
+  modifier&#x27;s level — so the evaluated mesh is exactly the subdivided shell,
+  not merely &quot;bigger&quot;;
+- the exported OBJ vertex count equals the summed EVALUATED counts of every
+  mesh object (modifier-applied), not the summed base counts.
 
 ``--unevaluated`` exports with ``apply_modifiers=False`` and still asserts
-the OBJ vertex count equals the depsgraph-evaluated mesh. That is the
+the OBJ vertex count equals the depsgraph-evaluated meshes. That is the
 falsifier (``--same-axis`` in export-preset-axis). ``--obj`` is a path
 selector, not a falsifier.
 
@@ -327,37 +339,315 @@ <h2>Source</h2>
     blender --background --python depsgraph_export.py -- --output d.png  # + render
 &quot;&quot;&quot;</span>
 <span class="k">import</span> bpy, bmesh, sys, os, math, argparse, tempfile
+<span class="k">from</span> mathutils <span class="k">import</span> Matrix, Vector
 
-<span class="c"># Shared Layer 1 framing measurement (render path only) — see gallery_framing.py</span>
+<span class="c"># Shared Layer 1 framing + asset-quality measurement (render path only) — see</span>
+<span class="c"># gallery_framing.py / gallery_asset_quality.py</span>
 sys.path.insert(<span class="n">0</span>, os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir))
 sys.dont_write_bytecode = <span class="k">True</span>  <span class="c"># keep examples/__pycache__ out of the repo tree</span>
 <span class="k">import</span> gallery_framing
+<span class="k">import</span> gallery_asset_quality
+
+SUBSURF_LEVELS = <span class="n">2</span>
+
+<span class="c"># ---------------------------------------------------------------------------</span>
+<span class="c"># Controller shell cage. A top-view quad grid (X across, Y toward the</span>
+<span class="c"># bumpers) with the notch between the grips cut out, extruded through three</span>
+<span class="c"># Z layers (bottom, seam, top). Every face is a quad; the solid is closed and</span>
+<span class="c"># manifold, which is what the closed form below relies on (it holds for any</span>
+<span class="c"># polygon mesh, but a closed quad cage keeps the count easy to audit:</span>
+<span class="c"># V = 2 * grid points + boundary points).</span>
+<span class="c"># ---------------------------------------------------------------------------</span>
+XS = (-<span class="n">3.2</span>, -<span class="n">2.3</span>, -<span class="n">1.2</span>, <span class="n">0.0</span>, <span class="n">1.2</span>, <span class="n">2.3</span>, <span class="n">3.2</span>)
+YS = (-<span class="n">2.4</span>, -<span class="n">1.3</span>, -<span class="n">0.3</span>, <span class="n">0.6</span>, <span class="n">1.3</span>)
+<span class="c"># kept cells per row (row 0 = grip tips, row 3 = bumper edge)</span>
+ROWS = (
+    (<span class="n">0</span>, <span class="n">1</span>, <span class="n">4</span>, <span class="n">5</span>),
+    (<span class="n">0</span>, <span class="n">1</span>, <span class="n">4</span>, <span class="n">5</span>),
+    (<span class="n">0</span>, <span class="n">1</span>, <span class="n">2</span>, <span class="n">3</span>, <span class="n">4</span>, <span class="n">5</span>),
+    (<span class="n">0</span>, <span class="n">1</span>, <span class="n">2</span>, <span class="n">3</span>, <span class="n">4</span>, <span class="n">5</span>),
+)
+
+
+<span class="k">def</span> _shape(i, j):
+    <span class="s">&quot;&quot;&quot;Shaped top-view position of grid point (i, j): grips splay and taper,
+    the notch between them arches up, the bumper edge rounds off.&quot;&quot;&quot;</span>
+    x, y = XS[i], YS[j]
+    ax, s = abs(x), (<span class="n">1.0</span> <span class="k">if</span> x &gt;= <span class="n">0</span> <span class="k">else</span> -<span class="n">1.0</span>)
+    <span class="k">if</span> j == <span class="n">0</span>:      <span class="c"># grip tips: narrower, splayed outward</span>
+        ax = {<span class="n">3.2</span>: <span class="n">2.85</span>, <span class="n">2.3</span>: <span class="n">2.05</span>, <span class="n">1.2</span>: <span class="n">1.3</span>}.get(ax, ax)
+        y -= <span class="n">0.10</span> * (ax / <span class="n">3.2</span>)
+        ax += <span class="n">0.25</span>
+    <span class="k">elif</span> j == <span class="n">1</span>:
+        ax = {<span class="n">3.2</span>: <span class="n">3.1</span>, <span class="n">1.2</span>: <span class="n">1.2</span>}.get(ax, ax)
+    <span class="k">elif</span> j == <span class="n">2</span> <span class="k">and</span> ax &lt; <span class="n">1.0</span>:   <span class="c"># arch of the notch between the grips</span>
+        y += <span class="n">0.25</span>
+    <span class="k">elif</span> j == <span class="n">4</span>:    <span class="c"># bumper edge: shoulders drop back, center stays</span>
+        y -= <span class="n">0.18</span> * (ax / <span class="n">3.2</span>) ** <span class="n">2</span>
+    <span class="k">return</span> s * ax, y
+
+
+<span class="k">def</span> _z(x, y, layer):
+    <span class="s">&quot;&quot;&quot;Z of a cage point: domed top, grips hang below the deck.&quot;&quot;&quot;</span>
+    t = max(<span class="n">0.0</span>, min(<span class="n">1.0</span>, (-<span class="n">0.3</span> - y) / <span class="n">2.1</span>))   <span class="c"># 0 on the deck, 1 at grip tips</span>
+    u = min(<span class="n">1.0</span>, abs(x) / <span class="n">3.2</span>)
+    top = <span class="n">0.62</span> + <span class="n">0.10</span> * (<span class="n">1.0</span> - u * u) - <span class="n">0.22</span> * t
+    bottom = -<span class="n">0.55</span> * t - <span class="n">0.05</span> * (<span class="n">1.0</span> - u)
+    <span class="k">if</span> layer == <span class="n">0</span>:
+        <span class="k">return</span> bottom
+    <span class="k">if</span> layer == <span class="n">1</span>:
+        <span class="k">return</span> bottom + <span class="n">0.55</span> * (top - bottom)
+    <span class="k">return</span> top
+
+
+<span class="k">def</span> build_shell_cage(me):
+    cells = {(i, j) <span class="k">for</span> j, cols <span class="k">in</span> enumerate(ROWS) <span class="k">for</span> i <span class="k">in</span> cols}
+    pts = sorted({(i + di, j + dj) <span class="k">for</span> (i, j) <span class="k">in</span> cells <span class="k">for</span> di <span class="k">in</span> (<span class="n">0</span>, <span class="n">1</span>) <span class="k">for</span> dj <span class="k">in</span> (<span class="n">0</span>, <span class="n">1</span>)})
+    <span class="c"># boundary edges of the kept-cell region, oriented CCW (region on the left)</span>
+    bedges = []
+    <span class="k">for</span> (i, j) <span class="k">in</span> cells:
+        <span class="k">for</span> (a, b, nb) <span class="k">in</span> (((i, j), (i + <span class="n">1</span>, j), (i, j - <span class="n">1</span>)),
+                           ((i + <span class="n">1</span>, j), (i + <span class="n">1</span>, j + <span class="n">1</span>), (i + <span class="n">1</span>, j)),
+                           ((i + <span class="n">1</span>, j + <span class="n">1</span>), (i, j + <span class="n">1</span>), (i, j + <span class="n">1</span>)),
+                           ((i, j + <span class="n">1</span>), (i, j), (i - <span class="n">1</span>, j))):
+            <span class="k">if</span> nb <span class="k">not</span> <span class="k">in</span> cells:
+                bedges.append((a, b))
+    bpts = sorted({p <span class="k">for</span> e <span class="k">in</span> bedges <span class="k">for</span> p <span class="k">in</span> e})
 
+    bm = bmesh.new()
+    <span class="k">try</span>:
+        layers = {}
+        <span class="k">for</span> layer <span class="k">in</span> (<span class="n">0</span>, <span class="n">2</span>):
+            <span class="k">for</span> p <span class="k">in</span> pts:
+                x, y = _shape(*p)
+                layers[(p, layer)] = bm.verts.new((x, y, _z(x, y, layer)))
+        <span class="k">for</span> p <span class="k">in</span> bpts:
+            x, y = _shape(*p)
+            layers[(p, <span class="n">1</span>)] = bm.verts.new((x, y, _z(x, y, <span class="n">1</span>)))
+        <span class="k">for</span> (i, j) <span class="k">in</span> cells:
+            quad = [(i, j), (i + <span class="n">1</span>, j), (i + <span class="n">1</span>, j + <span class="n">1</span>), (i, j + <span class="n">1</span>)]
+            bm.faces.new([layers[(p, <span class="n">2</span>)] <span class="k">for</span> p <span class="k">in</span> quad])            <span class="c"># top, up</span>
+            bm.faces.new([layers[(p, <span class="n">0</span>)] <span class="k">for</span> p <span class="k">in</span> reversed(quad)])  <span class="c"># bottom, down</span>
+        <span class="k">for</span> (a, b) <span class="k">in</span> bedges:
+            <span class="k">for</span> lo, hi <span class="k">in</span> ((<span class="n">0</span>, <span class="n">1</span>), (<span class="n">1</span>, <span class="n">2</span>)):
+                f = bm.faces.new([layers[(a, lo)], layers[(b, lo)],
+                                  layers[(b, hi)], layers[(a, hi)]])
+                f.material_index = <span class="n">1</span> <span class="k">if</span> lo == <span class="n">0</span> <span class="k">else</span> <span class="n">0</span>
+        <span class="k">for</span> f <span class="k">in</span> bm.faces:
+            <span class="k">if</span> f.normal.z &lt; -<span class="n">0.5</span>:
+                f.material_index = <span class="n">1</span>   <span class="c"># underside is the graphite half</span>
+        bmesh.ops.recalc_face_normals(bm, faces=bm.faces)
+        bm.to_mesh(me)
+    <span class="k">finally</span>:
+        bm.free()
 
-<span class="k">def</span> build():
-    bpy.ops.wm.read_factory_settings(use_empty=<span class="k">True</span>)
-    me = bpy.data.meshes.new(<span class="s">&quot;Cube&quot;</span>)
+
+<span class="k">def</span> catmull_clark_vcount(V, E, F, S, levels):
+    <span class="s">&quot;&quot;&quot;Vertex count after `levels` Catmull-Clark steps, from topology alone.
+
+    One step adds a vertex per edge and per face: V&#x27; = V + E + F. Each face
+    of n corners splits into n quads, so F&#x27; = S (face corners), E&#x27; = 2E + S,
+    and every later face is a quad: S&#x27; = 4F&#x27;.
+    &quot;&quot;&quot;</span>
+    <span class="k">for</span> _ <span class="k">in</span> range(levels):
+        V, E, F, S = V + E + F, <span class="n">2</span> * E + S, S, <span class="n">4</span> * S
+    <span class="k">return</span> V
+
+
+<span class="c"># ---------------------------------------------------------------------------</span>
+<span class="c"># Controls: ordinary modeled parts (no modifiers), so their evaluated count</span>
+<span class="c"># equals their base count and the export must carry them unchanged.</span>
+<span class="c"># ---------------------------------------------------------------------------</span>
+<span class="k">def</span> _bevel_all(bm, offset, segments=<span class="n">2</span>):
+    <span class="s">&quot;&quot;&quot;Round the rims only: the facet seams around a cylinder wall are
+    already shallow, and beveling them collapses slivers to zero area.&quot;&quot;&quot;</span>
+    rims = [e <span class="k">for</span> e <span class="k">in</span> bm.edges <span class="k">if</span> e.calc_face_angle(<span class="n">0.0</span>) &gt; math.radians(<span class="n">50</span>)]
+    bmesh.ops.bevel(bm, geom=rims, offset=offset, segments=segments,
+                    affect=<span class="s">&#x27;EDGES&#x27;</span>, profile=<span class="n">0.5</span>, clamp_overlap=<span class="k">True</span>)
+
+
+<span class="k">def</span> part_disc(me, r, h, segs=<span class="n">24</span>, bevel=<span class="n">0.03</span>, dish=<span class="n">0.0</span>):
+    <span class="s">&quot;&quot;&quot;A beveled puck standing on z=0 (button / stick cap); optional dished top.&quot;&quot;&quot;</span>
+    bm = bmesh.new()
+    <span class="k">try</span>:
+        bmesh.ops.create_cone(bm, cap_ends=<span class="k">True</span>, cap_tris=<span class="k">False</span>, segments=segs,
+                              radius1=r, radius2=r, depth=h,
+                              matrix=Matrix.Translation((<span class="n">0</span>, <span class="n">0</span>, h / <span class="n">2</span>)))
+        _bevel_all(bm, bevel)
+        <span class="k">if</span> dish:
+            <span class="k">for</span> v <span class="k">in</span> bm.verts:
+                <span class="k">if</span> v.co.z &gt; h - <span class="n">1e-4</span>:
+                    d = math.hypot(v.co.x, v.co.y) / r
+                    v.co.z -= dish * max(<span class="n">0.0</span>, <span class="n">1.0</span> - d * d)
+        bm.to_mesh(me)
+    <span class="k">finally</span>:
+        bm.free()
+
+
+<span class="k">def</span> part_stick(me):
+    <span class="s">&quot;&quot;&quot;Thumbstick: collar ring, neck, and a dished rubber cap.&quot;&quot;&quot;</span>
+    bm = bmesh.new()
+    <span class="k">try</span>:
+        <span class="k">for</span> (r1, r2, z0, z1) <span class="k">in</span> ((<span class="n">0.50</span>, <span class="n">0.46</span>, <span class="n">0.0</span>, <span class="n">0.06</span>),     <span class="c"># collar</span>
+                                 (<span class="n">0.17</span>, <span class="n">0.17</span>, <span class="n">0.06</span>, <span class="n">0.26</span>),    <span class="c"># neck</span>
+                                 (<span class="n">0.40</span>, <span class="n">0.40</span>, <span class="n">0.26</span>, <span class="n">0.40</span>)):   <span class="c"># cap</span>
+            bmesh.ops.create_cone(bm, cap_ends=<span class="k">True</span>, cap_tris=<span class="k">False</span>, segments=<span class="n">28</span>,
+                                  radius1=r1, radius2=r2, depth=z1 - z0,
+                                  matrix=Matrix.Translation((<span class="n">0</span>, <span class="n">0</span>, (z0 + z1) / <span class="n">2</span>)))
+        _bevel_all(bm, <span class="n">0.025</span>)
+        <span class="k">for</span> v <span class="k">in</span> bm.verts:
+            <span class="k">if</span> v.co.z &gt; <span class="n">0.40</span> - <span class="n">1e-4</span>:
+                d = math.hypot(v.co.x, v.co.y) / <span class="n">0.40</span>
+                v.co.z -= <span class="n">0.05</span> * max(<span class="n">0.0</span>, <span class="n">1.0</span> - d * d)
+        bm.to_mesh(me)
+    <span class="k">finally</span>:
+        bm.free()
+
+
+<span class="k">def</span> part_extrusion(me, outline, h, bevel):
+    <span class="s">&quot;&quot;&quot;Extrude a closed XY outline to height h, beveled (d-pad, pills, bumpers).&quot;&quot;&quot;</span>
     bm = bmesh.new()
     <span class="k">try</span>:
-        bmesh.ops.create_cube(bm, size=<span class="n">2.0</span>)
+        vs = [bm.verts.new((x, y, <span class="n">0.0</span>)) <span class="k">for</span> (x, y) <span class="k">in</span> outline]
+        face = bm.faces.new(vs)
+        ext = bmesh.ops.extrude_face_region(bm, geom=[face])
+        top = [e <span class="k">for</span> e <span class="k">in</span> ext[<span class="s">&quot;geom&quot;</span>] <span class="k">if</span> isinstance(e, bmesh.types.BMVert)]
+        bmesh.ops.translate(bm, verts=top, vec=(<span class="n">0</span>, <span class="n">0</span>, h))
+        bmesh.ops.recalc_face_normals(bm, faces=bm.faces)
+        _bevel_all(bm, bevel)
         bm.to_mesh(me)
     <span class="k">finally</span>:
         bm.free()
-    obj = bpy.data.objects.new(<span class="s">&quot;Cube&quot;</span>, me)
-    bpy.context.collection.objects.link(obj)
-    obj.modifiers.new(<span class="s">&quot;ss&quot;</span>, <span class="s">&#x27;SUBSURF&#x27;</span>).levels = <span class="n">2</span>
-    <span class="k">return</span> obj
 
 
-<span class="k">def</span> check(obj, obj_path, unevaluated=<span class="k">False</span>):
-    base = len(obj.data.vertices)
+<span class="k">def</span> _stadium(length, width, segs=<span class="n">8</span>):
+    r = width / <span class="n">2</span>
+    half = length / <span class="n">2</span> - r
+    pts = []
+    <span class="k">for</span> k <span class="k">in</span> range(segs + <span class="n">1</span>):
+        a = -math.pi / <span class="n">2</span> + math.pi * k / segs
+        pts.append((half + r * math.cos(a), r * math.sin(a)))
+    <span class="k">for</span> k <span class="k">in</span> range(segs + <span class="n">1</span>):
+        a = math.pi / <span class="n">2</span> + math.pi * k / segs
+        pts.append((-half + r * math.cos(a), r * math.sin(a)))
+    <span class="k">return</span> pts
 
-    <span class="c"># depsgraph lifetime contract: evaluate, read, then release with to_mesh_clear</span>
+
+<span class="k">def</span> _cross(arm, w):
+    a, b = arm, w / <span class="n">2</span>
+    <span class="k">return</span> [(b, -a), (b, -b), (a, -b), (a, b), (b, b), (b, a),
+            (-b, a), (-b, b), (-a, b), (-a, -b), (-b, -b), (-b, -a)]
+
+
+<span class="k">def</span> principled(name, color, metallic, roughness, emission=<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
+    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> emission:
+        key = <span class="s">&quot;Emission Color&quot;</span> <span class="k">if</span> <span class="s">&quot;Emission Color&quot;</span> <span class="k">in</span> bsdf.inputs <span class="k">else</span> <span class="s">&quot;Emission&quot;</span>
+        bsdf.inputs[key].default_value = color
+        bsdf.inputs[<span class="s">&quot;Emission Strength&quot;</span>].default_value = emission
+    <span class="k">return</span> mat
+
+
+<span class="k">def</span> _smooth(me, angle=<span class="n">35.0</span>):
+    <span class="s">&quot;&quot;&quot;Smooth shading with sharp breaks above `angle` (4.1+ mesh API).&quot;&quot;&quot;</span>
+    me.shade_smooth()
+    <span class="k">if</span> angle <span class="k">is</span> <span class="k">not</span> <span class="k">None</span>:
+        me.set_sharp_from_angle(angle=math.radians(angle))
+
+
+<span class="k">def</span> build():
+    bpy.ops.wm.read_factory_settings(use_empty=<span class="k">True</span>)
+    coll = bpy.context.collection
+
+    me = bpy.data.meshes.new(<span class="s">&quot;Gamepad.Shell&quot;</span>)
+    build_shell_cage(me)
+    me.materials.append(principled(<span class="s">&quot;Gamepad.Cobalt&quot;</span>, (<span class="n">0.014</span>, <span class="n">0.105</span>, <span class="n">0.54</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.34</span>))
+    me.materials.append(principled(<span class="s">&quot;Gamepad.Graphite&quot;</span>, (<span class="n">0.030</span>, <span class="n">0.032</span>, <span class="n">0.040</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.55</span>))
+    _smooth(me, <span class="k">None</span>)
+    shell = bpy.data.objects.new(<span class="s">&quot;Gamepad.Shell&quot;</span>, me)
+    coll.objects.link(shell)
+    ss = shell.modifiers.new(<span class="s">&quot;Subdivide&quot;</span>, <span class="s">&#x27;SUBSURF&#x27;</span>)
+    ss.levels = SUBSURF_LEVELS
+    ss.render_levels = SUBSURF_LEVELS
+
+    <span class="c"># Controls sit on the shell&#x27;s EVALUATED (subdivided) deck: ray-cast the</span>
+    <span class="c"># limit surface, not the cage, or every button floats above the plastic.</span>
     dg = bpy.context.evaluated_depsgraph_get()
-    ev = obj.evaluated_get(dg)
-    em = ev.to_mesh()
-    eval_vcount = len(em.vertices)
-    ev.to_mesh_clear()  <span class="c"># must be paired; releases the temporary mesh</span>
+
+    <span class="k">def</span> seat(ob, x, y, sink=<span class="n">0.02</span>):
+        hit, loc, nrm, _ = shell.ray_cast(Vector((x, y, <span class="n">5.0</span>)), Vector((<span class="n">0</span>, <span class="n">0</span>, -<span class="n">1</span>)),
+                                          depsgraph=dg)
+        <span class="k">if</span> <span class="k">not</span> hit:
+            <span class="k">raise</span> RuntimeError(<span class="s">f&quot;</span>{ob.name}<span class="s">: no shell under (</span>{x}<span class="s">, </span>{y}<span class="s">)</span><span class="s">&quot;</span>)
+        rot = nrm.to_track_quat(<span class="s">&#x27;Z&#x27;</span>, <span class="s">&#x27;Y&#x27;</span>).to_matrix().to_4x4()
+        ob.matrix_world = Matrix.Translation(loc - nrm * sink) @ rot
+        ob.parent = shell   <span class="c"># shell sits at the identity, so no parent inverse</span>
+
+    rubber = principled(<span class="s">&quot;Gamepad.Rubber&quot;</span>, (<span class="n">0.018</span>, <span class="n">0.019</span>, <span class="n">0.022</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.78</span>)
+    satin = principled(<span class="s">&quot;Gamepad.Satin&quot;</span>, (<span class="n">0.07</span>, <span class="n">0.075</span>, <span class="n">0.085</span>, <span class="n">1.0</span>), <span class="n">0.2</span>, <span class="n">0.42</span>)
+    face_cols = {<span class="s">&quot;A&quot;</span>: (<span class="n">0.02</span>, <span class="n">0.55</span>, <span class="n">0.12</span>, <span class="n">1.0</span>), <span class="s">&quot;B&quot;</span>: (<span class="n">0.75</span>, <span class="n">0.03</span>, <span class="n">0.02</span>, <span class="n">1.0</span>),
+                 <span class="s">&quot;X&quot;</span>: (<span class="n">0.03</span>, <span class="n">0.22</span>, <span class="n">0.85</span>, <span class="n">1.0</span>), <span class="s">&quot;Y&quot;</span>: (<span class="n">0.95</span>, <span class="n">0.62</span>, <span class="n">0.02</span>, <span class="n">1.0</span>)}
+
+    <span class="k">def</span> part(name, builder, mat, x, y, *args, **kw):
+        pme = bpy.data.meshes.new(name)
+        builder(pme, *args, **kw)
+        pme.materials.append(mat)
+        _smooth(pme)
+        ob = bpy.data.objects.new(name, pme)
+        coll.objects.link(ob)
+        seat(ob, x, y)
+        <span class="k">return</span> ob
+
+    part(<span class="s">&quot;Gamepad.StickL&quot;</span>, <span class="k">lambda</span> m: part_stick(m), rubber, -<span class="n">1.55</span>, -<span class="n">0.78</span>)
+    part(<span class="s">&quot;Gamepad.StickR&quot;</span>, <span class="k">lambda</span> m: part_stick(m), rubber, <span class="n">1.55</span>, -<span class="n">0.78</span>)
+    part(<span class="s">&quot;Gamepad.DPad&quot;</span>, part_extrusion, satin, -<span class="n">2.15</span>, <span class="n">0.25</span>,
+         _cross(<span class="n">0.46</span>, <span class="n">0.30</span>), <span class="n">0.12</span>, <span class="n">0.035</span>)
+    <span class="k">for</span> key, (dx, dy) <span class="k">in</span> {<span class="s">&quot;A&quot;</span>: (<span class="n">0</span>, -<span class="n">0.34</span>), <span class="s">&quot;B&quot;</span>: (<span class="n">0.34</span>, <span class="n">0</span>), <span class="s">&quot;X&quot;</span>: (-<span class="n">0.34</span>, <span class="n">0</span>),
+                          <span class="s">&quot;Y&quot;</span>: (<span class="n">0</span>, <span class="n">0.34</span>)}.items():
+        mat = principled(<span class="s">f&quot;</span><span class="s">Gamepad.Button</span>{key}<span class="s">&quot;</span>, face_cols[key], <span class="n">0.0</span>, <span class="n">0.30</span>, emission=<span class="n">0.12</span>)
+        part(<span class="s">f&quot;</span><span class="s">Gamepad.Button</span>{key}<span class="s">&quot;</span>, part_disc, mat, <span class="n">2.15</span> + dx, <span class="n">0.25</span> + dy,
+             <span class="n">0.15</span>, <span class="n">0.12</span>, <span class="n">20</span>, <span class="n">0.035</span>)
+    part(<span class="s">&quot;Gamepad.Select&quot;</span>, part_extrusion, satin, -<span class="n">0.62</span>, <span class="n">0.62</span>, _stadium(<span class="n">0.36</span>, <span class="n">0.13</span>), <span class="n">0.06</span>, <span class="n">0.02</span>)
+    part(<span class="s">&quot;Gamepad.Start&quot;</span>, part_extrusion, satin, <span class="n">0.62</span>, <span class="n">0.62</span>, _stadium(<span class="n">0.36</span>, <span class="n">0.13</span>), <span class="n">0.06</span>, <span class="n">0.02</span>)
+    home = principled(<span class="s">&quot;Gamepad.Home&quot;</span>, (<span class="n">1.0</span>, <span class="n">0.50</span>, <span class="n">0.10</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.3</span>, emission=<span class="n">0.8</span>)
+    part(<span class="s">&quot;Gamepad.Home&quot;</span>, part_disc, home, <span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.16</span>, <span class="n">0.06</span>, <span class="n">28</span>, <span class="n">0.02</span>)
+    <span class="k">for</span> side <span class="k">in</span> (-<span class="n">1</span>, <span class="n">1</span>):
+        b = part(<span class="s">f&quot;</span><span class="s">Gamepad.Bumper</span>{<span class="s">&#x27;L&#x27;</span> <span class="k">if</span> side &lt; <span class="n">0</span> <span class="k">else</span> <span class="s">&#x27;R&#x27;</span>}<span class="s">&quot;</span>, part_extrusion, satin,
+                 side * <span class="n">2.2</span>, <span class="n">1.16</span>, _stadium(<span class="n">1.5</span>, <span class="n">0.34</span>), <span class="n">0.15</span>, <span class="n">0.05</span>)
+        b.rotation_euler.z += math.radians(-side * <span class="n">8.0</span>)
+    <span class="k">return</span> shell
+
+
+<span class="k">def</span> mesh_objects():
+    <span class="k">return</span> sorted((o <span class="k">for</span> o <span class="k">in</span> bpy.context.scene.objects <span class="k">if</span> o.type == <span class="s">&#x27;MESH&#x27;</span>),
+                  key=<span class="k">lambda</span> o: o.name)
+
+
+<span class="k">def</span> check(shell, obj_path, unevaluated=<span class="k">False</span>):
+    base_total = <span class="n">0</span>
+    eval_total = <span class="n">0</span>
+    shell_eval = <span class="k">None</span>
+    <span class="c"># depsgraph lifetime contract: evaluate, read, then release with</span>
+    <span class="c"># to_mesh_clear — once per object, never holding two temporaries</span>
+    dg = bpy.context.evaluated_depsgraph_get()
+    <span class="k">for</span> ob <span class="k">in</span> mesh_objects():
+        ev = ob.evaluated_get(dg)
+        em = ev.to_mesh()
+        n = len(em.vertices)
+        ev.to_mesh_clear()  <span class="c"># must be paired; releases the temporary mesh</span>
+        base_total += len(ob.data.vertices)
+        eval_total += n
+        <span class="k">if</span> ob == shell:
+            shell_eval = n
+
+    me = shell.data
+    V, E, F, S = len(me.vertices), len(me.edges), len(me.polygons), len(me.loops)
+    expected = catmull_clark_vcount(V, E, F, S, SUBSURF_LEVELS)
 
     out = obj_path <span class="k">or</span> os.path.join(tempfile.gettempdir(), <span class="s">&quot;depsgraph_export.obj&quot;</span>)
     os.makedirs(os.path.dirname(os.path.abspath(out)) <span class="k">or</span> <span class="s">&quot;.&quot;</span>, exist_ok=<span class="k">True</span>)
@@ -371,17 +661,23 @@ <h2>Source</h2>
         print(<span class="s">&quot;ERROR: no OBJ written&quot;</span>, file=sys.stderr)
         <span class="k">return</span> <span class="n">4</span>
     exported = <span class="n">0</span>
-    <span class="k">with</span> open(out) <span class="k">as</span> f:
+    <span class="k">with</span> open(out, encoding=<span class="s">&quot;utf-8&quot;</span>) <span class="k">as</span> f:
         <span class="k">for</span> line <span class="k">in</span> f:
             <span class="k">if</span> line.startswith(<span class="s">&quot;v &quot;</span>):
                 exported += <span class="n">1</span>
 
-    print(<span class="s">f&quot;</span><span class="s">base_vcount=</span>{base}<span class="s"> eval_vcount=</span>{eval_vcount}<span class="s"> exported_vcount=</span>{exported}<span class="s">&quot;</span>)
-    <span class="k">if</span> <span class="k">not</span> (eval_vcount &gt; base):
+    print(<span class="s">f&quot;</span><span class="s">shell_cage V=</span>{V}<span class="s"> E=</span>{E}<span class="s"> F=</span>{F}<span class="s"> S=</span>{S}<span class="s"> levels=</span>{SUBSURF_LEVELS}<span class="s"> </span><span class="s">&quot;</span>
+          <span class="s">f&quot;</span><span class="s">shell_eval_vcount=</span>{shell_eval}<span class="s"> closed_form=</span>{expected}<span class="s">&quot;</span>)
+    print(<span class="s">f&quot;</span><span class="s">base_vcount=</span>{base_total}<span class="s"> eval_vcount=</span>{eval_total}<span class="s"> exported_vcount=</span>{exported}<span class="s">&quot;</span>)
+    <span class="k">if</span> <span class="k">not</span> (shell_eval &gt; V):
         print(<span class="s">&quot;ERROR: evaluated mesh did not apply the modifier&quot;</span>, file=sys.stderr)
         <span class="k">return</span> <span class="n">3</span>
-    <span class="k">if</span> exported != eval_vcount:
-        print(<span class="s">f&quot;</span><span class="s">ERROR: export (</span>{exported}<span class="s">) != evaluated (</span>{eval_vcount}<span class="s">); modifier did not ship</span><span class="s">&quot;</span>,
+    <span class="k">if</span> shell_eval != expected:
+        print(<span class="s">f&quot;</span><span class="s">ERROR: evaluated shell (</span>{shell_eval}<span class="s">) != Catmull-Clark closed form </span><span class="s">&quot;</span>
+              <span class="s">f&quot;</span><span class="s">(</span>{expected}<span class="s">)</span><span class="s">&quot;</span>, file=sys.stderr)
+        <span class="k">return</span> <span class="n">7</span>
+    <span class="k">if</span> exported != eval_total:
+        print(<span class="s">f&quot;</span><span class="s">ERROR: export (</span>{exported}<span class="s">) != evaluated (</span>{eval_total}<span class="s">); modifier did not ship</span><span class="s">&quot;</span>,
               file=sys.stderr)
         <span class="k">return</span> <span class="n">5</span>
     <span class="k">return</span> <span class="n">0</span>
@@ -391,84 +687,138 @@ <h2>Source</h2>
     <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> principled(name, color, metallic, roughness):
+<span class="k">def</span> ghost(name, color, alpha):
+    <span class="s">&quot;&quot;&quot;Tinted see-through shell for the cage: transparent mixed with a glossy
+    tint, so the sparse facets read as a volume and the wires stay dominant.&quot;&quot;&quot;</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>]
+    nt = mat.node_tree
+    bsdf = nt.nodes[<span class="s">&quot;Principled BSDF&quot;</span>]
     bsdf.inputs[<span class="s">&quot;Base Color&quot;</span>].default_value = color
-    bsdf.inputs[<span class="s">&quot;Metallic&quot;</span>].default_value = metallic
-    bsdf.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = roughness
+    bsdf.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.3</span>
+    out = nt.nodes[<span class="s">&quot;Material Output&quot;</span>]
+    mix = nt.nodes.new(<span class="s">&quot;ShaderNodeMixShader&quot;</span>)
+    mix.inputs[<span class="s">&quot;Fac&quot;</span>].default_value = alpha
+    tr = nt.nodes.new(<span class="s">&quot;ShaderNodeBsdfTransparent&quot;</span>)
+    nt.links.new(tr.outputs[<span class="n">0</span>], mix.inputs[<span class="n">1</span>])
+    nt.links.new(bsdf.outputs[<span class="n">0</span>], mix.inputs[<span class="n">2</span>])
+    nt.links.new(mix.outputs[<span class="n">0</span>], out.inputs[<span class="s">&quot;Surface&quot;</span>])
+    <span class="k">if</span> hasattr(mat, <span class="s">&quot;surface_render_method&quot;</span>):
+        mat.surface_render_method = <span class="s">&#x27;BLENDED&#x27;</span>
     <span class="k">return</span> mat
 
 
-<span class="k">def</span> render_still(obj, path, engine):
-    <span class="s">&quot;&quot;&quot;Base cube beside its evaluated form — the two counts the check compares.&quot;&quot;&quot;</span>
+<span class="k">def</span> render_still(shell, path, engine):
+    <span class="s">&quot;&quot;&quot;The cage the .blend holds beside the subdivided controller the OBJ ships.&quot;&quot;&quot;</span>
     scene = bpy.context.scene
+    coll = scene.collection
 
-    <span class="c"># one hero material on BOTH objects: the two silhouettes share a color so</span>
-    <span class="c"># the only visible difference is the thing the check measures — base-mesh</span>
-    <span class="c"># geometry versus the depsgraph-evaluated subsurf</span>
-    hero = principled(<span class="s">&quot;Teal&quot;</span>, (<span class="n">0.012</span>, <span class="n">0.30</span>, <span class="n">0.34</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.2</span>)
-
-    <span class="c"># left: the base mesh, modifier-free (a plain copy of the datablock)</span>
-    base_obj = bpy.data.objects.new(<span class="s">&quot;Base&quot;</span>, obj.data.copy())
-    base_obj.location = (-<span class="n">1.7</span>, <span class="n">0.0</span>, <span class="n">1.0</span>)
-    <span class="c"># turned off camera-parallel so the key rakes the front face into a</span>
-    <span class="c"># gradient instead of one flat tone</span>
-    base_obj.rotation_euler = (<span class="n">0.0</span>, <span class="n">0.0</span>, math.radians(<span class="n">32</span>))
-    base_obj.data.materials.append(hero)
-    bpy.context.collection.objects.link(base_obj)
-
-    <span class="c"># right: the SUBSURF object — what the depsgraph evaluates and the OBJ ships.</span>
-    <span class="c"># Rest it on the floor by measuring its own EVALUATED bounds (the subsurf</span>
-    <span class="c"># limit surface shrinks, so the base-mesh -1.0 is not where it ends).</span>
+    <span class="c"># right: the checked scene itself — shell + controls, the export&#x27;s content.</span>
+    <span class="c"># Tilted toward the camera on its grip tips, like a controller on a shelf.</span>
+    shell.rotation_euler = (math.radians(<span class="n">30</span>), <span class="n">0.0</span>, math.radians(-<span class="n">10</span>))
+    shell.location = (<span class="n">3.45</span>, -<span class="n">0.3</span>, <span class="n">0.0</span>)
+    bpy.context.view_layer.update()
     dg = bpy.context.evaluated_depsgraph_get()
-    em = obj.evaluated_get(dg).to_mesh()
-    bottom = min(v.co.z <span class="k">for</span> v <span class="k">in</span> em.vertices)
-    obj.evaluated_get(dg).to_mesh_clear()
-    obj.location = (<span class="n">1.8</span>, <span class="n">0.0</span>, -bottom)
-    obj.data.materials.append(hero)
-    <span class="k">for</span> poly <span class="k">in</span> obj.data.polygons:
-        poly.use_smooth = <span class="k">True</span>
-
-    <span class="c"># Edge cages over both: the check compares vertex counts, and two teal</span>
-    <span class="c"># silhouettes alone read as &quot;a cube and a ball&quot;. The base cage shows the</span>
-    <span class="c"># 8 verts the datablock holds; the evaluated cage is the same SUBSURF</span>
-    <span class="c"># followed by WIREFRAME, so it draws exactly the edges the OBJ ships.</span>
-    <span class="c"># Render-path scaffolding only: separate objects, added after check().</span>
-    cage_mat = principled(<span class="s">&quot;Cage&quot;</span>, (<span class="n">0.92</span>, <span class="n">0.80</span>, <span class="n">0.56</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.35</span>)
-    cages = []
-    <span class="k">for</span> src, subsurf <span class="k">in</span> ((base_obj, <span class="k">False</span>), (obj, <span class="k">True</span>)):
-        cage = bpy.data.objects.new(src.name + <span class="s">&quot;Cage&quot;</span>, obj.data.copy())
-        cage.data.materials.clear()
-        cage.data.materials.append(cage_mat)
-        cage.location = src.location
-        cage.rotation_euler = src.rotation_euler
-        <span class="k">if</span> subsurf:
-            cage.modifiers.new(<span class="s">&quot;ss&quot;</span>, <span class="s">&#x27;SUBSURF&#x27;</span>).levels = <span class="n">2</span>
-        wire = cage.modifiers.new(<span class="s">&quot;cage&quot;</span>, <span class="s">&#x27;WIREFRAME&#x27;</span>)
-        wire.thickness = <span class="n">0.035</span> <span class="k">if</span> <span class="k">not</span> subsurf <span class="k">else</span> <span class="n">0.018</span>
-        wire.offset = <span class="n">1.0</span>  <span class="c"># grow outward so the lines sit on the surface</span>
-        wire.use_even_offset = <span class="k">True</span>
-        bpy.context.collection.objects.link(cage)
-        cages.append(cage)
+    lows = []
+    <span class="k">for</span> ob <span class="k">in</span> mesh_objects():
+        ev = ob.evaluated_get(dg)
+        em = ev.to_mesh()
+        mw = ob.matrix_world
+        lows.append(min((mw @ v.co).z <span class="k">for</span> v <span class="k">in</span> em.vertices))
+        ev.to_mesh_clear()
+    shell.location.z = -min(lows)
+    bpy.context.view_layer.update()
+    product = mesh_objects()
+
+    <span class="c"># left: the shell&#x27;s base datablock with no modifier — the sparse control</span>
+    <span class="c"># cage the file stores. Warm wire on every cage edge, a bead on every</span>
+    <span class="c"># cage vertex (the V the closed form starts from), faint cobalt facets.</span>
+    cage_mat = principled(<span class="s">&quot;Cage.Wire&quot;</span>, (<span class="n">1.0</span>, <span class="n">0.42</span>, <span class="n">0.06</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.35</span>, emission=<span class="n">0.6</span>)
+    xf = Matrix.Translation((-<span class="n">3.45</span>, <span class="n">0.3</span>, <span class="n">0.0</span>)) @ \
+        Matrix.Rotation(math.radians(<span class="n">10</span>), <span class="n">4</span>, <span class="s">&#x27;Z&#x27;</span>) @ Matrix.Rotation(math.radians(<span class="n">30</span>), <span class="n">4</span>, <span class="s">&#x27;X&#x27;</span>)
+    cage_me = shell.data.copy()
+    cage_me.name = <span class="s">&quot;Cage.Shell&quot;</span>
+    cage_me.materials.clear()
+    cage_me.materials.append(ghost(<span class="s">&quot;Cage.Ghost&quot;</span>, (<span class="n">0.02</span>, <span class="n">0.12</span>, <span class="n">0.55</span>, <span class="n">1.0</span>), <span class="n">0.30</span>))
+    <span class="k">for</span> p <span class="k">in</span> cage_me.polygons:
+        p.material_index = <span class="n">0</span>
+    cage_me.shade_flat()
+    cage_shell = bpy.data.objects.new(<span class="s">&quot;Cage.Shell&quot;</span>, cage_me)
+    wire = bpy.data.objects.new(<span class="s">&quot;Cage.Wire&quot;</span>, shell.data.copy())
+    wire.data.materials.clear()
+    wire.data.materials.append(cage_mat)
+    w = wire.modifiers.new(<span class="s">&quot;wire&quot;</span>, <span class="s">&#x27;WIREFRAME&#x27;</span>)
+    w.thickness = <span class="n">0.045</span>
+    w.offset = <span class="n">0.0</span>
+    w.use_even_offset = <span class="k">True</span>
+    beads_me = bpy.data.meshes.new(<span class="s">&quot;Cage.Beads&quot;</span>)
+    bm = bmesh.new()
+    <span class="k">try</span>:
+        <span class="k">for</span> v <span class="k">in</span> shell.data.vertices:
+            bmesh.ops.create_icosphere(bm, subdivisions=<span class="n">2</span>, radius=<span class="n">0.075</span>,
+                                       matrix=Matrix.Translation(v.co))
+        bm.to_mesh(beads_me)
+    <span class="k">finally</span>:
+        bm.free()
+    beads_me.materials.append(cage_mat)
+    beads_me.shade_smooth()
+    beads = bpy.data.objects.new(<span class="s">&quot;Cage.Beads&quot;</span>, beads_me)
+    cage = [cage_shell, wire, beads]
+    <span class="k">for</span> ob <span class="k">in</span> cage:
+        ob.matrix_world = xf
+        coll.objects.link(ob)
+    bpy.context.view_layer.update()
+    low = min((xf @ v.co).z <span class="k">for</span> v <span class="k">in</span> shell.data.vertices) - <span class="n">0.075</span>
+    <span class="k">for</span> ob <span class="k">in</span> cage:
+        ob.location.z -= low
+    bpy.context.view_layer.update()
+
+    <span class="c"># Display stands: both pieces are tilted toward the camera, so each back</span>
+    <span class="c"># edge rests on a low satin block instead of hanging in the air. Sized</span>
+    <span class="c"># from the real underside — the evaluated shell for the product, the</span>
+    <span class="c"># cage points for the cage. Render-only; the export already ran.</span>
+    stand_mat = principled(<span class="s">&quot;Stand.Satin&quot;</span>, (<span class="n">0.055</span>, <span class="n">0.057</span>, <span class="n">0.066</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.45</span>)
+
+    <span class="k">def</span> stand(name, mw, coords, yaw):
+        back = [mw @ c <span class="k">for</span> c <span class="k">in</span> coords <span class="k">if</span> c.y &gt; <span class="n">0.55</span> <span class="k">and</span> c.z &lt; <span class="n">0.15</span>]
+        top = min(p.z <span class="k">for</span> p <span class="k">in</span> back)
+        cx = sum(p.x <span class="k">for</span> p <span class="k">in</span> back) / len(back)
+        cy = sum(p.y <span class="k">for</span> p <span class="k">in</span> back) / len(back)
+        sme = bpy.data.meshes.new(name)
+        part_extrusion(sme, [(-<span class="n">2.3</span>, -<span class="n">0.42</span>), (<span class="n">2.3</span>, -<span class="n">0.42</span>), (<span class="n">2.3</span>, <span class="n">0.42</span>), (-<span class="n">2.3</span>, <span class="n">0.42</span>)],
+                       top, <span class="n">0.05</span>)
+        sme.materials.append(stand_mat)
+        _smooth(sme)
+        ob = bpy.data.objects.new(name, sme)
+        ob.location = (cx, cy, <span class="n">0.0</span>)
+        ob.rotation_euler = (<span class="n">0.0</span>, <span class="n">0.0</span>, yaw)
+        coll.objects.link(ob)
+        <span class="k">return</span> ob
+
+    ev = shell.evaluated_get(dg)
+    em = ev.to_mesh()
+    shell_pts = [v.co.copy() <span class="k">for</span> v <span class="k">in</span> em.vertices]
+    ev.to_mesh_clear()
+    stands = [
+        stand(<span class="s">&quot;Stand.Product&quot;</span>, shell.matrix_world, shell_pts, math.radians(-<span class="n">10</span>)),
+        stand(<span class="s">&quot;Stand.Cage&quot;</span>, cage_shell.matrix_world,
+              [v.co <span class="k">for</span> v <span class="k">in</span> shell.data.vertices], math.radians(<span class="n">10</span>)),
+    ]
 
     floor_me = bpy.data.meshes.new(<span class="s">&quot;Floor&quot;</span>)
     bm = bmesh.new()
     <span class="k">try</span>:
-        bmesh.ops.create_grid(bm, x_segments=<span class="n">1</span>, y_segments=<span class="n">1</span>, size=<span class="n">30.0</span>)
+        bmesh.ops.create_grid(bm, x_segments=<span class="n">1</span>, y_segments=<span class="n">1</span>, size=<span class="n">60.0</span>)
         bm.to_mesh(floor_me)
     <span class="k">finally</span>:
         bm.free()
     floor_me.materials.append(principled(<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">1.0</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)
+    coll.objects.link(floor)
     wall = bpy.data.objects.new(<span class="s">&quot;Wall&quot;</span>, floor_me.copy())
-    wall.data.materials.clear()
-    wall.data.materials.append(principled(<span class="s">&quot;Wall&quot;</span>, (<span class="n">0.03</span>, <span class="n">0.032</span>, <span class="n">0.037</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.7</span>))
-    wall.location = (<span class="n">0.0</span>, <span class="n">9.0</span>, <span class="n">0.0</span>)
+    wall.location = (<span class="n">0.0</span>, <span class="n">8.0</span>, <span class="n">0.0</span>)
     wall.rotation_euler = (math.pi / <span class="n">2</span>, <span class="n">0.0</span>, <span class="n">0.0</span>)
-    scene.collection.objects.link(wall)
+    coll.objects.link(wall)
 
     world = bpy.data.worlds.new(<span class="s">&quot;World&quot;</span>)
     world.use_nodes = <span class="k">True</span>
@@ -482,25 +832,23 @@ <h2>Source</h2>
         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)
+        coll.objects.link(ob)
 
-    <span class="c"># warm shaped key, faint cool fill, warm wedge on the back wall</span>
+    <span class="c"># warm shaped key, faint cool fill, cool rim, warm wedge on the back wall</span>
     <span class="c"># (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">650.0</span>, <span class="n">5.0</span>, (<span class="n">1.0</span>, <span class="n">0.96</span>, <span class="n">0.9</span>), (<span class="n">46</span>, <span class="n">0</span>, -<span class="n">35</span>))
-    light(<span class="s">&quot;Fill&quot;</span>, (<span class="n">5.0</span>, -<span class="n">3.5</span>, <span class="n">3.0</span>), <span class="n">120.0</span>, <span class="n">9.0</span>, (<span class="n">0.75</span>, <span class="n">0.85</span>, <span class="n">1.0</span>), (<span class="n">62</span>, <span class="n">0</span>, <span class="n">50</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">380.0</span>, <span class="n">6.0</span>, (<span class="n">1.0</span>, <span class="n">0.76</span>, <span class="n">0.5</span>), (-<span class="n">68</span>, <span class="n">0</span>, <span class="n">190</span>))
+    light(<span class="s">&quot;Key&quot;</span>, (-<span class="n">4.0</span>, -<span class="n">5.0</span>, <span class="n">6.5</span>), <span class="n">580.0</span>, <span class="n">5.0</span>, (<span class="n">1.0</span>, <span class="n">0.96</span>, <span class="n">0.9</span>), (<span class="n">42</span>, <span class="n">0</span>, -<span class="n">38</span>))
+    light(<span class="s">&quot;Fill&quot;</span>, (<span class="n">7.0</span>, -<span class="n">6.0</span>, <span class="n">4.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">40</span>, <span class="n">0</span>, <span class="n">50</span>))
+    light(<span class="s">&quot;Rim&quot;</span>, (<span class="n">1.5</span>, <span class="n">5.0</span>, <span class="n">4.5</span>), <span class="n">260.0</span>, <span class="n">4.0</span>, (<span class="n">0.6</span>, <span class="n">0.78</span>, <span class="n">1.0</span>), (-<span class="n">55</span>, <span class="n">0</span>, <span class="n">180</span>))
+    light(<span class="s">&quot;Wedge&quot;</span>, (<span class="n">0.5</span>, <span class="n">6.0</span>, <span class="n">3.0</span>), <span class="n">420.0</span>, <span class="n">6.0</span>, (<span class="n">1.0</span>, <span class="n">0.76</span>, <span class="n">0.5</span>), (-<span class="n">72</span>, <span class="n">0</span>, <span class="n">180</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)
-    <span class="c"># Reframed: the rotated base cube spans ~5.9 units with the evaluated</span>
-    <span class="c"># sphere, wider than the old (0,-7.4,3.0) frame — the cube was amputated</span>
-    <span class="c"># at the left edge. Aim-based framing on the pair&#x27;s center.</span>
-    cam.location = (<span class="n">0.0</span>, -<span class="n">9.6</span>, <span class="n">2.6</span>)
-    scene.collection.objects.link(cam)
+    cam.location = (<span class="n">0.0</span>, -<span class="n">19.0</span>, <span class="n">13.2</span>)
+    coll.objects.link(cam)
     aim = bpy.data.objects.new(<span class="s">&quot;Aim&quot;</span>, <span class="k">None</span>)
-    aim.location = (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.9</span>)
-    scene.collection.objects.link(aim)
+    aim.location = (<span class="n">0.0</span>, <span class="n">0.3</span>, <span class="n">0.55</span>)
+    coll.objects.link(aim)
     con = cam.constraints.new(<span class="s">&#x27;TRACK_TO&#x27;</span>)
     con.target = aim
     con.track_axis = <span class="s">&#x27;TRACK_NEGATIVE_Z&#x27;</span>
@@ -509,7 +857,7 @@ <h2>Source</h2>
 
     scene.render.engine = <span class="s">&#x27;CYCLES&#x27;</span> <span class="k">if</span> engine == <span class="s">&#x27;cycles&#x27;</span> <span class="k">else</span> eevee_engine_id()
     <span class="k">if</span> engine == <span class="s">&#x27;cycles&#x27;</span>:
-        scene.cycles.samples = <span class="n">32</span>
+        scene.cycles.samples = <span class="n">48</span>
     <span class="k">else</span>:
         <span class="k">try</span>:
             scene.eevee.taa_render_samples = <span class="n">64</span>
@@ -519,19 +867,24 @@ <h2>Source</h2>
     scene.render.resolution_y = <span class="n">720</span>
     scene.render.image_settings.file_format = <span class="s">&#x27;PNG&#x27;</span>
     scene.render.filepath = path
-    <span class="c"># AgX would flatten the graphite-vs-green contrast this still hinges on</span>
+    <span class="c"># AgX would wash the cobalt shell and the orange cage toward pastel</span>
     <span class="c"># (docs/VISUAL-STYLE.md)</span>
     scene.view_settings.view_transform = <span class="s">&#x27;Standard&#x27;</span>
     <span class="c"># Layer 1 framing gate (silhouette matte) — exit 10 on violation, before</span>
     <span class="c"># the beauty render so a defective composition ships no artifact.</span>
     fcode = gallery_framing.check_framing(
         scene, cam,
-        hero=[base_obj, obj],
-        elements=[base_obj, obj] + cages,
+        hero=product + cage,
+        elements=product + cage + stands,
         stage=[floor, wall],
     )
     <span class="k">if</span> fcode:
         <span class="k">return</span> fcode
+    <span class="c"># Asset-quality floors on the shipped controller (exit 11).</span>
+    qcode = gallery_asset_quality.check_asset_quality(scene, cam, hero=product,
+                                                      stage=[floor, wall])
+    <span class="k">if</span> qcode:
+        <span class="k">return</span> qcode
     bpy.ops.render.render(write_still=<span class="k">True</span>)
     <span class="k">if</span> <span class="k">not</span> (os.path.exists(path) <span class="k">and</span> os.path.getsize(path) &gt; <span class="n">0</span>):
         print(<span class="s">&quot;ERROR: render produced no file&quot;</span>, file=sys.stderr)
@@ -551,13 +904,13 @@ <h2>Source</h2>
                    help=<span class="s">&quot;export with apply_modifiers=False (must fail)&quot;</span>)
     args = p.parse_args(argv)
 
-    obj = build()
-    code = check(obj, args.obj, unevaluated=args.unevaluated)
+    shell = build()
+    code = check(shell, args.obj, unevaluated=args.unevaluated)
     <span class="k">if</span> code:
         <span class="k">return</span> code
 
     <span class="k">if</span> args.output:
-        rcode = render_still(obj, os.path.abspath(args.output), args.engine)
+        rcode = render_still(shell, os.path.abspath(args.output), args.engine)
         <span class="k">if</span> rcode:
             <span class="k">return</span> rcode
         print(<span class="s">f&quot;</span><span class="s">rendered still </span>{args.output}<span class="s">&quot;</span>)
@@ -576,7 +929,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/depsgraph-export-hero.webp" alt="A teal cube outlined by its twelve edges beside a faceted teal sphere covered in a dense pale wire grid, on a dark studio floor." />
+    <img src="../assets/depsgraph-export-hero.webp" alt="A game controller&#x27;s sparse control cage in orange wire and vertex beads beside the smooth subdivided cobalt controller with sticks and colored buttons, on a dark studio floor." />
   </dialog>
   <footer>
     <div class="statusbar">
diff --git a/docs/gallery/index.html b/docs/gallery/index.html
index a24bf2f5..58574fd7 100644
--- a/docs/gallery/index.html
+++ b/docs/gallery/index.html
@@ -376,12 +376,12 @@ <h2><a href="gn-sdf-remesh/">gn-sdf-remesh</a></h2>
       </article>
       <article class="card" data-tags="depsgraph export">
         <a class="card-media" href="depsgraph-export/" tabindex="-1" aria-hidden="true">
-          <img src="assets/depsgraph-export-hero.webp" alt="A teal cube outlined by its twelve edges beside a faceted teal sphere covered in a dense pale wire grid, on a dark studio floor." loading="lazy" decoding="async" />
+          <img src="assets/depsgraph-export-hero.webp" alt="A game controller&#x27;s sparse control cage in orange wire and vertex beads beside the smooth subdivided cobalt controller with sticks and colored buttons, on a dark studio floor." loading="lazy" decoding="async" />
         </a>
         <div class="card-body">
           <h2><a href="depsgraph-export/">depsgraph-export</a></h2>
           <p class="teaches">The depsgraph lifetime contract — evaluated_get().to_mesh() paired with to_mesh_clear() — measured against an OBJ export of the same object.</p>
-          <p class="witnesses"><span class="tag">witnesses</span> Exports ship evaluated geometry: the exported vertex count equals the subsurf-applied count and is strictly greater than the base mesh.</p>
+          <p class="witnesses"><span class="tag">witnesses</span> Exports ship evaluated geometry: the controller shell subdivides to exactly its Catmull-Clark closed form, and the exported vertex count equals the subsurf-applied count, strictly greater than the base mesh.</p>
           <a class="card-link" href="depsgraph-export/">View example<span class="sr-only"> depsgraph-export</span> <span aria-hidden="true">&rarr;</span></a>
         </div>
       </article>
diff --git a/examples/depsgraph-export/README.md b/examples/depsgraph-export/README.md
index 6ddfaca8..b1188a57 100644
--- a/examples/depsgraph-export/README.md
+++ b/examples/depsgraph-export/README.md
@@ -2,15 +2,32 @@
 
 A runnable example that proves **modifiers actually ship in exports** and demonstrates the
 [`depsgraph-and-evaluated-data`](../../skills/depsgraph-and-evaluated-data/SKILL.md) lifetime
-contract. It builds a cube with a SUBSURF modifier, measures the evaluated mesh via
-`evaluated_get().to_mesh()` (paired with `to_mesh_clear()`), exports through `wm.obj_export`,
-and asserts the exported vertex count equals the **evaluated** (modifier-applied) count and is
-strictly greater than the base mesh.
+contract. It builds a game controller whose shell is a sparse quad control cage (90 vertices)
+under a level-2 `SUBSURF` modifier, with the sticks, d-pad, face buttons and bumpers modeled
+as ordinary parts parented to it. It measures every mesh via `evaluated_get().to_mesh()`
+(each paired with `to_mesh_clear()`), exports the scene through `wm.obj_export`, and asserts:
+
+- the evaluated shell has exactly the vertex count the Catmull-Clark closed form predicts
+  from the cage's own topology — per level `V' = V + E + F`, `E' = 2E + S`, `F' = S`
+  (S = face corners) — which for this cage (V=90, E=176, F=88, S=352) is **1,410**;
+- the exported OBJ vertex count equals the summed **evaluated** counts of every mesh
+  (3,666), not the summed base counts (2,346).
 
 **What it witnesses:** the `evaluated_get` → `to_mesh` → `to_mesh_clear` contract, and that
 `wm.obj_export` writes the depsgraph-evaluated geometry (so modifiers are baked into the
 export) rather than the unmodified base mesh.
 
+## The render
+
+Left: the shell datablock as the `.blend` stores it — its 90-vertex control cage drawn as
+orange wire with a bead on every vertex, over faint blue facets. Right: the same object as the
+depsgraph evaluates it and the OBJ contains it — the smooth subdivided cobalt controller with
+its controls. If the export shipped the base mesh, the right-hand piece would be the blocky
+cage on the left.
+
+Both pieces lean toward the camera on low satin display stands (render-only, added after the
+check and export have run).
+
 ## Run
 
 ```bash
@@ -20,7 +37,7 @@ blender --background --python depsgraph_export.py --
 # Falsifier: apply_modifiers=False. Must exit non-zero (export ≠ evaluated).
 blender --background --python depsgraph_export.py -- --unevaluated
 
-# Also render a still of base vs evaluated (EEVEE on a GPU host; cycles on GPU-less hosts):
+# Also render a still of cage vs evaluated (EEVEE on a GPU host; cycles on GPU-less hosts):
 blender --background --python depsgraph_export.py -- --output depsgraph.png
 blender --background --python depsgraph_export.py -- --output depsgraph.png --engine cycles
 
@@ -31,18 +48,20 @@ blender --background --python depsgraph_export.py -- --obj exported.obj
 ## Exit codes
 
 Per-script sequential checks. `9` is a valid check code; there is no rule
-against it. `10` is the shared framing helper.
+against it. `10` and `11` are the shared framing and asset-quality helpers.
 
 | Code | Meaning |
 | --- | --- |
 | 0 | Success |
 | 1 | Uncaught exception (FATAL wrapper) |
 | 2 | argparse / usage |
-| 3 | Evaluated mesh did not apply the modifier |
+| 3 | Evaluated shell did not apply the modifier (evaluated count not above the cage) |
 | 4 | No OBJ written |
 | 5 | Export vert count ≠ evaluated (`--unevaluated` lands here) |
 | 6 | `--output` produced no file |
+| 7 | Evaluated shell count ≠ Catmull-Clark closed form |
 | 10 | Gallery framing violation |
+| 11 | Asset-quality floor violation (render path only) |
 
 `--obj` is a path selector, not a falsifier.
 
@@ -50,5 +69,6 @@ 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).
 Smoke does not pass `--output`, `--obj`, or `--unevaluated`.
 
-
-The `--output` render path additionally measures framing against the Layer 1 band via `examples/gallery_framing.py` (exit 10 on violation) before writing the still.
+The `--output` render path additionally measures framing against the Layer 1 band via
+`examples/gallery_framing.py` (exit 10) and the asset-quality floors on the shipped
+controller via `examples/gallery_asset_quality.py` (exit 11) before writing the still.
diff --git a/examples/depsgraph-export/depsgraph_export.py b/examples/depsgraph-export/depsgraph_export.py
index 24447baa..e8a052af 100644
--- a/examples/depsgraph-export/depsgraph_export.py
+++ b/examples/depsgraph-export/depsgraph_export.py
@@ -1,13 +1,21 @@
 """Depsgraph-evaluated export — a runnable example.
 
 Witnesses the depsgraph lifetime contract AND that modifiers actually ship in
-exports. Builds a cube with a SUBSURF modifier, measures the evaluated mesh via
-evaluated_get().to_mesh() (paired with to_mesh_clear()), exports through
-wm.obj_export, and asserts the exported vertex count equals the EVALUATED
-(modifier-applied) count and is strictly greater than the base.
+exports. Builds a game controller whose shell is a sparse quad control cage
+under a SUBSURF modifier (the buttons, sticks and bumpers are plain modeled
+parts parented to it), measures every mesh through
+evaluated_get().to_mesh() (each paired with to_mesh_clear()), exports the
+scene through wm.obj_export, and asserts:
+
+- the shell's evaluated vertex count equals the Catmull-Clark closed form
+  computed from its own cage topology (V, E, F, face corners) at the
+  modifier's level — so the evaluated mesh is exactly the subdivided shell,
+  not merely "bigger";
+- the exported OBJ vertex count equals the summed EVALUATED counts of every
+  mesh object (modifier-applied), not the summed base counts.
 
 ``--unevaluated`` exports with ``apply_modifiers=False`` and still asserts
-the OBJ vertex count equals the depsgraph-evaluated mesh. That is the
+the OBJ vertex count equals the depsgraph-evaluated meshes. That is the
 falsifier (``--same-axis`` in export-preset-axis). ``--obj`` is a path
 selector, not a falsifier.
 
@@ -19,37 +27,315 @@
     blender --background --python depsgraph_export.py -- --output d.png  # + render
 """
 import bpy, bmesh, sys, os, math, argparse, tempfile
+from mathutils import Matrix, Vector
 
-# Shared Layer 1 framing measurement (render path only) — see gallery_framing.py
+# Shared Layer 1 framing + asset-quality measurement (render path only) — see
+# gallery_framing.py / gallery_asset_quality.py
 sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir))
 sys.dont_write_bytecode = True  # keep examples/__pycache__ out of the repo tree
 import gallery_framing
+import gallery_asset_quality
+
+SUBSURF_LEVELS = 2
+
+# ---------------------------------------------------------------------------
+# Controller shell cage. A top-view quad grid (X across, Y toward the
+# bumpers) with the notch between the grips cut out, extruded through three
+# Z layers (bottom, seam, top). Every face is a quad; the solid is closed and
+# manifold, which is what the closed form below relies on (it holds for any
+# polygon mesh, but a closed quad cage keeps the count easy to audit:
+# V = 2 * grid points + boundary points).
+# ---------------------------------------------------------------------------
+XS = (-3.2, -2.3, -1.2, 0.0, 1.2, 2.3, 3.2)
+YS = (-2.4, -1.3, -0.3, 0.6, 1.3)
+# kept cells per row (row 0 = grip tips, row 3 = bumper edge)
+ROWS = (
+    (0, 1, 4, 5),
+    (0, 1, 4, 5),
+    (0, 1, 2, 3, 4, 5),
+    (0, 1, 2, 3, 4, 5),
+)
+
+
+def _shape(i, j):
+    """Shaped top-view position of grid point (i, j): grips splay and taper,
+    the notch between them arches up, the bumper edge rounds off."""
+    x, y = XS[i], YS[j]
+    ax, s = abs(x), (1.0 if x >= 0 else -1.0)
+    if j == 0:      # grip tips: narrower, splayed outward
+        ax = {3.2: 2.85, 2.3: 2.05, 1.2: 1.3}.get(ax, ax)
+        y -= 0.10 * (ax / 3.2)
+        ax += 0.25
+    elif j == 1:
+        ax = {3.2: 3.1, 1.2: 1.2}.get(ax, ax)
+    elif j == 2 and ax < 1.0:   # arch of the notch between the grips
+        y += 0.25
+    elif j == 4:    # bumper edge: shoulders drop back, center stays
+        y -= 0.18 * (ax / 3.2) ** 2
+    return s * ax, y
+
+
+def _z(x, y, layer):
+    """Z of a cage point: domed top, grips hang below the deck."""
+    t = max(0.0, min(1.0, (-0.3 - y) / 2.1))   # 0 on the deck, 1 at grip tips
+    u = min(1.0, abs(x) / 3.2)
+    top = 0.62 + 0.10 * (1.0 - u * u) - 0.22 * t
+    bottom = -0.55 * t - 0.05 * (1.0 - u)
+    if layer == 0:
+        return bottom
+    if layer == 1:
+        return bottom + 0.55 * (top - bottom)
+    return top
+
+
+def build_shell_cage(me):
+    cells = {(i, j) for j, cols in enumerate(ROWS) for i in cols}
+    pts = sorted({(i + di, j + dj) for (i, j) in cells for di in (0, 1) for dj in (0, 1)})
+    # boundary edges of the kept-cell region, oriented CCW (region on the left)
+    bedges = []
+    for (i, j) in cells:
+        for (a, b, nb) in (((i, j), (i + 1, j), (i, j - 1)),
+                           ((i + 1, j), (i + 1, j + 1), (i + 1, j)),
+                           ((i + 1, j + 1), (i, j + 1), (i, j + 1)),
+                           ((i, j + 1), (i, j), (i - 1, j))):
+            if nb not in cells:
+                bedges.append((a, b))
+    bpts = sorted({p for e in bedges for p in e})
 
+    bm = bmesh.new()
+    try:
+        layers = {}
+        for layer in (0, 2):
+            for p in pts:
+                x, y = _shape(*p)
+                layers[(p, layer)] = bm.verts.new((x, y, _z(x, y, layer)))
+        for p in bpts:
+            x, y = _shape(*p)
+            layers[(p, 1)] = bm.verts.new((x, y, _z(x, y, 1)))
+        for (i, j) in cells:
+            quad = [(i, j), (i + 1, j), (i + 1, j + 1), (i, j + 1)]
+            bm.faces.new([layers[(p, 2)] for p in quad])            # top, up
+            bm.faces.new([layers[(p, 0)] for p in reversed(quad)])  # bottom, down
+        for (a, b) in bedges:
+            for lo, hi in ((0, 1), (1, 2)):
+                f = bm.faces.new([layers[(a, lo)], layers[(b, lo)],
+                                  layers[(b, hi)], layers[(a, hi)]])
+                f.material_index = 1 if lo == 0 else 0
+        for f in bm.faces:
+            if f.normal.z < -0.5:
+                f.material_index = 1   # underside is the graphite half
+        bmesh.ops.recalc_face_normals(bm, faces=bm.faces)
+        bm.to_mesh(me)
+    finally:
+        bm.free()
 
-def build():
-    bpy.ops.wm.read_factory_settings(use_empty=True)
-    me = bpy.data.meshes.new("Cube")
+
+def catmull_clark_vcount(V, E, F, S, levels):
+    """Vertex count after `levels` Catmull-Clark steps, from topology alone.
+
+    One step adds a vertex per edge and per face: V' = V + E + F. Each face
+    of n corners splits into n quads, so F' = S (face corners), E' = 2E + S,
+    and every later face is a quad: S' = 4F'.
+    """
+    for _ in range(levels):
+        V, E, F, S = V + E + F, 2 * E + S, S, 4 * S
+    return V
+
+
+# ---------------------------------------------------------------------------
+# Controls: ordinary modeled parts (no modifiers), so their evaluated count
+# equals their base count and the export must carry them unchanged.
+# ---------------------------------------------------------------------------
+def _bevel_all(bm, offset, segments=2):
+    """Round the rims only: the facet seams around a cylinder wall are
+    already shallow, and beveling them collapses slivers to zero area."""
+    rims = [e for e in bm.edges if e.calc_face_angle(0.0) > math.radians(50)]
+    bmesh.ops.bevel(bm, geom=rims, offset=offset, segments=segments,
+                    affect='EDGES', profile=0.5, clamp_overlap=True)
+
+
+def part_disc(me, r, h, segs=24, bevel=0.03, dish=0.0):
+    """A beveled puck standing on z=0 (button / stick cap); optional dished top."""
+    bm = bmesh.new()
+    try:
+        bmesh.ops.create_cone(bm, cap_ends=True, cap_tris=False, segments=segs,
+                              radius1=r, radius2=r, depth=h,
+                              matrix=Matrix.Translation((0, 0, h / 2)))
+        _bevel_all(bm, bevel)
+        if dish:
+            for v in bm.verts:
+                if v.co.z > h - 1e-4:
+                    d = math.hypot(v.co.x, v.co.y) / r
+                    v.co.z -= dish * max(0.0, 1.0 - d * d)
+        bm.to_mesh(me)
+    finally:
+        bm.free()
+
+
+def part_stick(me):
+    """Thumbstick: collar ring, neck, and a dished rubber cap."""
+    bm = bmesh.new()
+    try:
+        for (r1, r2, z0, z1) in ((0.50, 0.46, 0.0, 0.06),     # collar
+                                 (0.17, 0.17, 0.06, 0.26),    # neck
+                                 (0.40, 0.40, 0.26, 0.40)):   # cap
+            bmesh.ops.create_cone(bm, cap_ends=True, cap_tris=False, segments=28,
+                                  radius1=r1, radius2=r2, depth=z1 - z0,
+                                  matrix=Matrix.Translation((0, 0, (z0 + z1) / 2)))
+        _bevel_all(bm, 0.025)
+        for v in bm.verts:
+            if v.co.z > 0.40 - 1e-4:
+                d = math.hypot(v.co.x, v.co.y) / 0.40
+                v.co.z -= 0.05 * max(0.0, 1.0 - d * d)
+        bm.to_mesh(me)
+    finally:
+        bm.free()
+
+
+def part_extrusion(me, outline, h, bevel):
+    """Extrude a closed XY outline to height h, beveled (d-pad, pills, bumpers)."""
     bm = bmesh.new()
     try:
-        bmesh.ops.create_cube(bm, size=2.0)
+        vs = [bm.verts.new((x, y, 0.0)) for (x, y) in outline]
+        face = bm.faces.new(vs)
+        ext = bmesh.ops.extrude_face_region(bm, geom=[face])
+        top = [e for e in ext["geom"] if isinstance(e, bmesh.types.BMVert)]
+        bmesh.ops.translate(bm, verts=top, vec=(0, 0, h))
+        bmesh.ops.recalc_face_normals(bm, faces=bm.faces)
+        _bevel_all(bm, bevel)
         bm.to_mesh(me)
     finally:
         bm.free()
-    obj = bpy.data.objects.new("Cube", me)
-    bpy.context.collection.objects.link(obj)
-    obj.modifiers.new("ss", 'SUBSURF').levels = 2
-    return obj
 
 
-def check(obj, obj_path, unevaluated=False):
-    base = len(obj.data.vertices)
+def _stadium(length, width, segs=8):
+    r = width / 2
+    half = length / 2 - r
+    pts = []
+    for k in range(segs + 1):
+        a = -math.pi / 2 + math.pi * k / segs
+        pts.append((half + r * math.cos(a), r * math.sin(a)))
+    for k in range(segs + 1):
+        a = math.pi / 2 + math.pi * k / segs
+        pts.append((-half + r * math.cos(a), r * math.sin(a)))
+    return pts
 
-    # depsgraph lifetime contract: evaluate, read, then release with to_mesh_clear
+
+def _cross(arm, w):
+    a, b = arm, w / 2
+    return [(b, -a), (b, -b), (a, -b), (a, b), (b, b), (b, a),
+            (-b, a), (-b, b), (-a, b), (-a, -b), (-b, -b), (-b, -a)]
+
+
+def principled(name, color, metallic, roughness, emission=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
+    bsdf.inputs["Metallic"].default_value = metallic
+    bsdf.inputs["Roughness"].default_value = roughness
+    if emission:
+        key = "Emission Color" if "Emission Color" in bsdf.inputs else "Emission"
+        bsdf.inputs[key].default_value = color
+        bsdf.inputs["Emission Strength"].default_value = emission
+    return mat
+
+
+def _smooth(me, angle=35.0):
+    """Smooth shading with sharp breaks above `angle` (4.1+ mesh API)."""
+    me.shade_smooth()
+    if angle is not None:
+        me.set_sharp_from_angle(angle=math.radians(angle))
+
+
+def build():
+    bpy.ops.wm.read_factory_settings(use_empty=True)
+    coll = bpy.context.collection
+
+    me = bpy.data.meshes.new("Gamepad.Shell")
+    build_shell_cage(me)
+    me.materials.append(principled("Gamepad.Cobalt", (0.014, 0.105, 0.54, 1.0), 0.0, 0.34))
+    me.materials.append(principled("Gamepad.Graphite", (0.030, 0.032, 0.040, 1.0), 0.0, 0.55))
+    _smooth(me, None)
+    shell = bpy.data.objects.new("Gamepad.Shell", me)
+    coll.objects.link(shell)
+    ss = shell.modifiers.new("Subdivide", 'SUBSURF')
+    ss.levels = SUBSURF_LEVELS
+    ss.render_levels = SUBSURF_LEVELS
+
+    # Controls sit on the shell's EVALUATED (subdivided) deck: ray-cast the
+    # limit surface, not the cage, or every button floats above the plastic.
     dg = bpy.context.evaluated_depsgraph_get()
-    ev = obj.evaluated_get(dg)
-    em = ev.to_mesh()
-    eval_vcount = len(em.vertices)
-    ev.to_mesh_clear()  # must be paired; releases the temporary mesh
+
+    def seat(ob, x, y, sink=0.02):
+        hit, loc, nrm, _ = shell.ray_cast(Vector((x, y, 5.0)), Vector((0, 0, -1)),
+                                          depsgraph=dg)
+        if not hit:
+            raise RuntimeError(f"{ob.name}: no shell under ({x}, {y})")
+        rot = nrm.to_track_quat('Z', 'Y').to_matrix().to_4x4()
+        ob.matrix_world = Matrix.Translation(loc - nrm * sink) @ rot
+        ob.parent = shell   # shell sits at the identity, so no parent inverse
+
+    rubber = principled("Gamepad.Rubber", (0.018, 0.019, 0.022, 1.0), 0.0, 0.78)
+    satin = principled("Gamepad.Satin", (0.07, 0.075, 0.085, 1.0), 0.2, 0.42)
+    face_cols = {"A": (0.02, 0.55, 0.12, 1.0), "B": (0.75, 0.03, 0.02, 1.0),
+                 "X": (0.03, 0.22, 0.85, 1.0), "Y": (0.95, 0.62, 0.02, 1.0)}
+
+    def part(name, builder, mat, x, y, *args, **kw):
+        pme = bpy.data.meshes.new(name)
+        builder(pme, *args, **kw)
+        pme.materials.append(mat)
+        _smooth(pme)
+        ob = bpy.data.objects.new(name, pme)
+        coll.objects.link(ob)
+        seat(ob, x, y)
+        return ob
+
+    part("Gamepad.StickL", lambda m: part_stick(m), rubber, -1.55, -0.78)
+    part("Gamepad.StickR", lambda m: part_stick(m), rubber, 1.55, -0.78)
+    part("Gamepad.DPad", part_extrusion, satin, -2.15, 0.25,
+         _cross(0.46, 0.30), 0.12, 0.035)
+    for key, (dx, dy) in {"A": (0, -0.34), "B": (0.34, 0), "X": (-0.34, 0),
+                          "Y": (0, 0.34)}.items():
+        mat = principled(f"Gamepad.Button{key}", face_cols[key], 0.0, 0.30, emission=0.12)
+        part(f"Gamepad.Button{key}", part_disc, mat, 2.15 + dx, 0.25 + dy,
+             0.15, 0.12, 20, 0.035)
+    part("Gamepad.Select", part_extrusion, satin, -0.62, 0.62, _stadium(0.36, 0.13), 0.06, 0.02)
+    part("Gamepad.Start", part_extrusion, satin, 0.62, 0.62, _stadium(0.36, 0.13), 0.06, 0.02)
+    home = principled("Gamepad.Home", (1.0, 0.50, 0.10, 1.0), 0.0, 0.3, emission=0.8)
+    part("Gamepad.Home", part_disc, home, 0.0, 0.0, 0.16, 0.06, 28, 0.02)
+    for side in (-1, 1):
+        b = part(f"Gamepad.Bumper{'L' if side < 0 else 'R'}", part_extrusion, satin,
+                 side * 2.2, 1.16, _stadium(1.5, 0.34), 0.15, 0.05)
+        b.rotation_euler.z += math.radians(-side * 8.0)
+    return shell
+
+
+def mesh_objects():
+    return sorted((o for o in bpy.context.scene.objects if o.type == 'MESH'),
+                  key=lambda o: o.name)
+
+
+def check(shell, obj_path, unevaluated=False):
+    base_total = 0
+    eval_total = 0
+    shell_eval = None
+    # depsgraph lifetime contract: evaluate, read, then release with
+    # to_mesh_clear — once per object, never holding two temporaries
+    dg = bpy.context.evaluated_depsgraph_get()
+    for ob in mesh_objects():
+        ev = ob.evaluated_get(dg)
+        em = ev.to_mesh()
+        n = len(em.vertices)
+        ev.to_mesh_clear()  # must be paired; releases the temporary mesh
+        base_total += len(ob.data.vertices)
+        eval_total += n
+        if ob == shell:
+            shell_eval = n
+
+    me = shell.data
+    V, E, F, S = len(me.vertices), len(me.edges), len(me.polygons), len(me.loops)
+    expected = catmull_clark_vcount(V, E, F, S, SUBSURF_LEVELS)
 
     out = obj_path or os.path.join(tempfile.gettempdir(), "depsgraph_export.obj")
     os.makedirs(os.path.dirname(os.path.abspath(out)) or ".", exist_ok=True)
@@ -63,17 +349,23 @@ def check(obj, obj_path, unevaluated=False):
         print("ERROR: no OBJ written", file=sys.stderr)
         return 4
     exported = 0
-    with open(out) as f:
+    with open(out, encoding="utf-8") as f:
         for line in f:
             if line.startswith("v "):
                 exported += 1
 
-    print(f"base_vcount={base} eval_vcount={eval_vcount} exported_vcount={exported}")
-    if not (eval_vcount > base):
+    print(f"shell_cage V={V} E={E} F={F} S={S} levels={SUBSURF_LEVELS} "
+          f"shell_eval_vcount={shell_eval} closed_form={expected}")
+    print(f"base_vcount={base_total} eval_vcount={eval_total} exported_vcount={exported}")
+    if not (shell_eval > V):
         print("ERROR: evaluated mesh did not apply the modifier", file=sys.stderr)
         return 3
-    if exported != eval_vcount:
-        print(f"ERROR: export ({exported}) != evaluated ({eval_vcount}); modifier did not ship",
+    if shell_eval != expected:
+        print(f"ERROR: evaluated shell ({shell_eval}) != Catmull-Clark closed form "
+              f"({expected})", file=sys.stderr)
+        return 7
+    if exported != eval_total:
+        print(f"ERROR: export ({exported}) != evaluated ({eval_total}); modifier did not ship",
               file=sys.stderr)
         return 5
     return 0
@@ -83,84 +375,138 @@ def eevee_engine_id():
     return 'BLENDER_EEVEE' if bpy.app.version >= (5, 0, 0) else 'BLENDER_EEVEE_NEXT'
 
 
-def principled(name, color, metallic, roughness):
+def ghost(name, color, alpha):
+    """Tinted see-through shell for the cage: transparent mixed with a glossy
+    tint, so the sparse facets read as a volume and the wires stay dominant."""
     mat = bpy.data.materials.new(name)
     mat.use_nodes = True
-    bsdf = mat.node_tree.nodes["Principled BSDF"]
+    nt = mat.node_tree
+    bsdf = nt.nodes["Principled BSDF"]
     bsdf.inputs["Base Color"].default_value = color
-    bsdf.inputs["Metallic"].default_value = metallic
-    bsdf.inputs["Roughness"].default_value = roughness
+    bsdf.inputs["Roughness"].default_value = 0.3
+    out = nt.nodes["Material Output"]
+    mix = nt.nodes.new("ShaderNodeMixShader")
+    mix.inputs["Fac"].default_value = alpha
+    tr = nt.nodes.new("ShaderNodeBsdfTransparent")
+    nt.links.new(tr.outputs[0], mix.inputs[1])
+    nt.links.new(bsdf.outputs[0], mix.inputs[2])
+    nt.links.new(mix.outputs[0], out.inputs["Surface"])
+    if hasattr(mat, "surface_render_method"):
+        mat.surface_render_method = 'BLENDED'
     return mat
 
 
-def render_still(obj, path, engine):
-    """Base cube beside its evaluated form — the two counts the check compares."""
+def render_still(shell, path, engine):
+    """The cage the .blend holds beside the subdivided controller the OBJ ships."""
     scene = bpy.context.scene
+    coll = scene.collection
 
-    # one hero material on BOTH objects: the two silhouettes share a color so
-    # the only visible difference is the thing the check measures — base-mesh
-    # geometry versus the depsgraph-evaluated subsurf
-    hero = principled("Teal", (0.012, 0.30, 0.34, 1.0), 0.0, 0.2)
-
-    # left: the base mesh, modifier-free (a plain copy of the datablock)
-    base_obj = bpy.data.objects.new("Base", obj.data.copy())
-    base_obj.location = (-1.7, 0.0, 1.0)
-    # turned off camera-parallel so the key rakes the front face into a
-    # gradient instead of one flat tone
-    base_obj.rotation_euler = (0.0, 0.0, math.radians(32))
-    base_obj.data.materials.append(hero)
-    bpy.context.collection.objects.link(base_obj)
-
-    # right: the SUBSURF object — what the depsgraph evaluates and the OBJ ships.
-    # Rest it on the floor by measuring its own EVALUATED bounds (the subsurf
-    # limit surface shrinks, so the base-mesh -1.0 is not where it ends).
+    # right: the checked scene itself — shell + controls, the export's content.
+    # Tilted toward the camera on its grip tips, like a controller on a shelf.
+    shell.rotation_euler = (math.radians(30), 0.0, math.radians(-10))
+    shell.location = (3.45, -0.3, 0.0)
+    bpy.context.view_layer.update()
     dg = bpy.context.evaluated_depsgraph_get()
-    em = obj.evaluated_get(dg).to_mesh()
-    bottom = min(v.co.z for v in em.vertices)
-    obj.evaluated_get(dg).to_mesh_clear()
-    obj.location = (1.8, 0.0, -bottom)
-    obj.data.materials.append(hero)
-    for poly in obj.data.polygons:
-        poly.use_smooth = True
-
-    # Edge cages over both: the check compares vertex counts, and two teal
-    # silhouettes alone read as "a cube and a ball". The base cage shows the
-    # 8 verts the datablock holds; the evaluated cage is the same SUBSURF
-    # followed by WIREFRAME, so it draws exactly the edges the OBJ ships.
-    # Render-path scaffolding only: separate objects, added after check().
-    cage_mat = principled("Cage", (0.92, 0.80, 0.56, 1.0), 0.0, 0.35)
-    cages = []
-    for src, subsurf in ((base_obj, False), (obj, True)):
-        cage = bpy.data.objects.new(src.name + "Cage", obj.data.copy())
-        cage.data.materials.clear()
-        cage.data.materials.append(cage_mat)
-        cage.location = src.location
-        cage.rotation_euler = src.rotation_euler
-        if subsurf:
-            cage.modifiers.new("ss", 'SUBSURF').levels = 2
-        wire = cage.modifiers.new("cage", 'WIREFRAME')
-        wire.thickness = 0.035 if not subsurf else 0.018
-        wire.offset = 1.0  # grow outward so the lines sit on the surface
-        wire.use_even_offset = True
-        bpy.context.collection.objects.link(cage)
-        cages.append(cage)
+    lows = []
+    for ob in mesh_objects():
+        ev = ob.evaluated_get(dg)
+        em = ev.to_mesh()
+        mw = ob.matrix_world
+        lows.append(min((mw @ v.co).z for v in em.vertices))
+        ev.to_mesh_clear()
+    shell.location.z = -min(lows)
+    bpy.context.view_layer.update()
+    product = mesh_objects()
+
+    # left: the shell's base datablock with no modifier — the sparse control
+    # cage the file stores. Warm wire on every cage edge, a bead on every
+    # cage vertex (the V the closed form starts from), faint cobalt facets.
+    cage_mat = principled("Cage.Wire", (1.0, 0.42, 0.06, 1.0), 0.0, 0.35, emission=0.6)
+    xf = Matrix.Translation((-3.45, 0.3, 0.0)) @ \
+        Matrix.Rotation(math.radians(10), 4, 'Z') @ Matrix.Rotation(math.radians(30), 4, 'X')
+    cage_me = shell.data.copy()
+    cage_me.name = "Cage.Shell"
+    cage_me.materials.clear()
+    cage_me.materials.append(ghost("Cage.Ghost", (0.02, 0.12, 0.55, 1.0), 0.30))
+    for p in cage_me.polygons:
+        p.material_index = 0
+    cage_me.shade_flat()
+    cage_shell = bpy.data.objects.new("Cage.Shell", cage_me)
+    wire = bpy.data.objects.new("Cage.Wire", shell.data.copy())
+    wire.data.materials.clear()
+    wire.data.materials.append(cage_mat)
+    w = wire.modifiers.new("wire", 'WIREFRAME')
+    w.thickness = 0.045
+    w.offset = 0.0
+    w.use_even_offset = True
+    beads_me = bpy.data.meshes.new("Cage.Beads")
+    bm = bmesh.new()
+    try:
+        for v in shell.data.vertices:
+            bmesh.ops.create_icosphere(bm, subdivisions=2, radius=0.075,
+                                       matrix=Matrix.Translation(v.co))
+        bm.to_mesh(beads_me)
+    finally:
+        bm.free()
+    beads_me.materials.append(cage_mat)
+    beads_me.shade_smooth()
+    beads = bpy.data.objects.new("Cage.Beads", beads_me)
+    cage = [cage_shell, wire, beads]
+    for ob in cage:
+        ob.matrix_world = xf
+        coll.objects.link(ob)
+    bpy.context.view_layer.update()
+    low = min((xf @ v.co).z for v in shell.data.vertices) - 0.075
+    for ob in cage:
+        ob.location.z -= low
+    bpy.context.view_layer.update()
+
+    # Display stands: both pieces are tilted toward the camera, so each back
+    # edge rests on a low satin block instead of hanging in the air. Sized
+    # from the real underside — the evaluated shell for the product, the
+    # cage points for the cage. Render-only; the export already ran.
+    stand_mat = principled("Stand.Satin", (0.055, 0.057, 0.066, 1.0), 0.0, 0.45)
+
+    def stand(name, mw, coords, yaw):
+        back = [mw @ c for c in coords if c.y > 0.55 and c.z < 0.15]
+        top = min(p.z for p in back)
+        cx = sum(p.x for p in back) / len(back)
+        cy = sum(p.y for p in back) / len(back)
+        sme = bpy.data.meshes.new(name)
+        part_extrusion(sme, [(-2.3, -0.42), (2.3, -0.42), (2.3, 0.42), (-2.3, 0.42)],
+                       top, 0.05)
+        sme.materials.append(stand_mat)
+        _smooth(sme)
+        ob = bpy.data.objects.new(name, sme)
+        ob.location = (cx, cy, 0.0)
+        ob.rotation_euler = (0.0, 0.0, yaw)
+        coll.objects.link(ob)
+        return ob
+
+    ev = shell.evaluated_get(dg)
+    em = ev.to_mesh()
+    shell_pts = [v.co.copy() for v in em.vertices]
+    ev.to_mesh_clear()
+    stands = [
+        stand("Stand.Product", shell.matrix_world, shell_pts, math.radians(-10)),
+        stand("Stand.Cage", cage_shell.matrix_world,
+              [v.co for v in shell.data.vertices], math.radians(10)),
+    ]
 
     floor_me = bpy.data.meshes.new("Floor")
     bm = bmesh.new()
     try:
-        bmesh.ops.create_grid(bm, x_segments=1, y_segments=1, size=30.0)
+        bmesh.ops.create_grid(bm, x_segments=1, y_segments=1, size=60.0)
         bm.to_mesh(floor_me)
     finally:
         bm.free()
     floor_me.materials.append(principled("Studio", (0.03, 0.032, 0.037, 1.0), 0.0, 0.7))
     floor = bpy.data.objects.new("Floor", floor_me)
-    scene.collection.objects.link(floor)
+    coll.objects.link(floor)
     wall = bpy.data.objects.new("Wall", floor_me.copy())
-    wall.data.materials.clear()
-    wall.data.materials.append(principled("Wall", (0.03, 0.032, 0.037, 1.0), 0.0, 0.7))
-    wall.location = (0.0, 9.0, 0.0)
+    wall.location = (0.0, 8.0, 0.0)
     wall.rotation_euler = (math.pi / 2, 0.0, 0.0)
-    scene.collection.objects.link(wall)
+    coll.objects.link(wall)
 
     world = bpy.data.worlds.new("World")
     world.use_nodes = True
@@ -174,25 +520,23 @@ def light(name, loc, energy, size, col, rot):
         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)
+        coll.objects.link(ob)
 
-    # warm shaped key, faint cool fill, warm wedge on the back wall
+    # warm shaped key, faint cool fill, cool rim, warm wedge on the back wall
     # (docs/VISUAL-STYLE.md)
-    light("Key", (-4.0, -5.0, 6.0), 650.0, 5.0, (1.0, 0.96, 0.9), (46, 0, -35))
-    light("Fill", (5.0, -3.5, 3.0), 120.0, 9.0, (0.75, 0.85, 1.0), (62, 0, 50))
-    light("Wedge", (2.5, 5.5, 4.0), 380.0, 6.0, (1.0, 0.76, 0.5), (-68, 0, 190))
+    light("Key", (-4.0, -5.0, 6.5), 580.0, 5.0, (1.0, 0.96, 0.9), (42, 0, -38))
+    light("Fill", (7.0, -6.0, 4.5), 110.0, 9.0, (0.75, 0.85, 1.0), (40, 0, 50))
+    light("Rim", (1.5, 5.0, 4.5), 260.0, 4.0, (0.6, 0.78, 1.0), (-55, 0, 180))
+    light("Wedge", (0.5, 6.0, 3.0), 420.0, 6.0, (1.0, 0.76, 0.5), (-72, 0, 180))
 
     cam_data = bpy.data.cameras.new("Cam")
     cam_data.lens = 50.0
     cam = bpy.data.objects.new("Cam", cam_data)
-    # Reframed: the rotated base cube spans ~5.9 units with the evaluated
-    # sphere, wider than the old (0,-7.4,3.0) frame — the cube was amputated
-    # at the left edge. Aim-based framing on the pair's center.
-    cam.location = (0.0, -9.6, 2.6)
-    scene.collection.objects.link(cam)
+    cam.location = (0.0, -19.0, 13.2)
+    coll.objects.link(cam)
     aim = bpy.data.objects.new("Aim", None)
-    aim.location = (0.0, 0.0, 0.9)
-    scene.collection.objects.link(aim)
+    aim.location = (0.0, 0.3, 0.55)
+    coll.objects.link(aim)
     con = cam.constraints.new('TRACK_TO')
     con.target = aim
     con.track_axis = 'TRACK_NEGATIVE_Z'
@@ -201,7 +545,7 @@ def light(name, loc, energy, size, col, rot):
 
     scene.render.engine = 'CYCLES' if engine == 'cycles' else eevee_engine_id()
     if engine == 'cycles':
-        scene.cycles.samples = 32
+        scene.cycles.samples = 48
     else:
         try:
             scene.eevee.taa_render_samples = 64
@@ -211,19 +555,24 @@ def light(name, loc, energy, size, col, rot):
     scene.render.resolution_y = 720
     scene.render.image_settings.file_format = 'PNG'
     scene.render.filepath = path
-    # AgX would flatten the graphite-vs-green contrast this still hinges on
+    # AgX would wash the cobalt shell and the orange cage toward pastel
     # (docs/VISUAL-STYLE.md)
     scene.view_settings.view_transform = 'Standard'
     # Layer 1 framing gate (silhouette matte) — exit 10 on violation, before
     # the beauty render so a defective composition ships no artifact.
     fcode = gallery_framing.check_framing(
         scene, cam,
-        hero=[base_obj, obj],
-        elements=[base_obj, obj] + cages,
+        hero=product + cage,
+        elements=product + cage + stands,
         stage=[floor, wall],
     )
     if fcode:
         return fcode
+    # Asset-quality floors on the shipped controller (exit 11).
+    qcode = gallery_asset_quality.check_asset_quality(scene, cam, hero=product,
+                                                      stage=[floor, wall])
+    if qcode:
+        return qcode
     bpy.ops.render.render(write_still=True)
     if not (os.path.exists(path) and os.path.getsize(path) > 0):
         print("ERROR: render produced no file", file=sys.stderr)
@@ -243,13 +592,13 @@ def main():
                    help="export with apply_modifiers=False (must fail)")
     args = p.parse_args(argv)
 
-    obj = build()
-    code = check(obj, args.obj, unevaluated=args.unevaluated)
+    shell = build()
+    code = check(shell, args.obj, unevaluated=args.unevaluated)
     if code:
         return code
 
     if args.output:
-        rcode = render_still(obj, os.path.abspath(args.output), args.engine)
+        rcode = render_still(shell, os.path.abspath(args.output), args.engine)
         if rcode:
             return rcode
         print(f"rendered still {args.output}")
diff --git a/examples/depsgraph-export/preview.webp b/examples/depsgraph-export/preview.webp
index 5bc5aad1..fe32efdd 100644
Binary files a/examples/depsgraph-export/preview.webp and b/examples/depsgraph-export/preview.webp differ
diff --git a/examples/gallery.json b/examples/gallery.json
index 859f6490..c0fd65ca 100644
--- a/examples/gallery.json
+++ b/examples/gallery.json
@@ -47,8 +47,8 @@
       "name": "depsgraph-export",
       "dir": "examples/depsgraph-export",
       "teaches": "The depsgraph lifetime contract — evaluated_get().to_mesh() paired with to_mesh_clear() — measured against an OBJ export of the same object.",
-      "alt": "A teal cube outlined by its twelve edges beside a faceted teal sphere covered in a dense pale wire grid, on a dark studio floor.",
-      "witnessesFix": "Exports ship evaluated geometry: the exported vertex count equals the subsurf-applied count and is strictly greater than the base mesh.",
+      "alt": "A game controller's sparse control cage in orange wire and vertex beads beside the smooth subdivided cobalt controller with sticks and colored buttons, on a dark studio floor.",
+      "witnessesFix": "Exports ship evaluated geometry: the controller shell subdivides to exactly its Catmull-Clark closed form, and the exported vertex count equals the subsurf-applied count, strictly greater than the base mesh.",
       "hero": "docs/gallery/assets/depsgraph-export-hero.webp",
       "preview": "examples/depsgraph-export/preview.webp",
       "tags": [
diff --git a/scripts/asset_sheet.py b/scripts/asset_sheet.py
index 7f9bd197..c2ea8e62 100644
--- a/scripts/asset_sheet.py
+++ b/scripts/asset_sheet.py
@@ -76,6 +76,7 @@
     "gn-modifier-inputs": (r"^SpiralStair\.H3$", None),
     "gltf-export-roundtrip": (r"^Crate\.Authored$", None),
     "shape-key-blend": (r"^Vase$", None),
+    "depsgraph-export": (r"^Gamepad\.", None),
 }
 
 _REF_LINE = re.compile(r"Asset-sheet gate.*?reference set — currently (.+?) — rendered", re.S)