diff --git a/README.md b/README.md
index 2507a446..284bcba9 100644
--- a/README.md
+++ b/README.md
@@ -832,7 +832,7 @@ portable path is `radius`.
 <table>
 <tr>
 <td width="46%" valign="middle">
-<a href="examples/gltf-export-roundtrip/"><img src="examples/gltf-export-roundtrip/preview.webp" alt="glTF export round-trip: two identical olive-drab sci-fi supply crates turned three-quarter on a dark studio floor - authored beside re-imported - with teal status strips, riveted panels, and corner armor, proving the export/import round-trip preserves the asset" /></a>
+<a href="examples/gltf-export-roundtrip/"><img src="examples/gltf-export-roundtrip/preview.webp" alt="glTF export round-trip: one olive-drab sci-fi supply crate on a dark studio floor, its right half traced by an amber wire cage of the re-imported glTF triangles that lands exactly on every bevel, rivet and vent slat, proving the export/import round-trip preserves the asset" /></a>
 </td>
 <td valign="middle">
 
diff --git a/docs/gallery/asset-sheets/gltf-export-roundtrip.webp b/docs/gallery/asset-sheets/gltf-export-roundtrip.webp
new file mode 100644
index 00000000..3657e8c1
Binary files /dev/null and b/docs/gallery/asset-sheets/gltf-export-roundtrip.webp differ
diff --git a/docs/gallery/assets/gltf-export-roundtrip-hero.webp b/docs/gallery/assets/gltf-export-roundtrip-hero.webp
index 3f1b9073..e65b15be 100644
Binary files a/docs/gallery/assets/gltf-export-roundtrip-hero.webp and b/docs/gallery/assets/gltf-export-roundtrip-hero.webp differ
diff --git a/docs/gallery/contact-sheets/gltf-export-roundtrip-contact-sheet.webp b/docs/gallery/contact-sheets/gltf-export-roundtrip-contact-sheet.webp
index e11db566..1df3e625 100644
Binary files a/docs/gallery/contact-sheets/gltf-export-roundtrip-contact-sheet.webp and b/docs/gallery/contact-sheets/gltf-export-roundtrip-contact-sheet.webp differ
diff --git a/docs/gallery/gltf-export-roundtrip/index.html b/docs/gallery/gltf-export-roundtrip/index.html
index 9956835f..1efafb09 100644
--- a/docs/gallery/gltf-export-roundtrip/index.html
+++ b/docs/gallery/gltf-export-roundtrip/index.html
@@ -16,13 +16,13 @@
   <meta property="og:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/gltf-export-roundtrip-hero.webp" />
   <meta property="og:image:width" content="1280" />
   <meta property="og:image:height" content="720" />
-  <meta property="og:image:alt" content="Two identical olive equipment crates with cyan light strips, both turned to show a side, labelled AUTHORED and ROUND-TRIP." />
+  <meta property="og:image:alt" content="One olive sci-fi supply crate with a cyan light strip, its right half traced by an amber wire cage of the re-imported glTF triangles that lands exactly on every bevel, rivet and vent slat." />
   <meta property="og:site_name" content="Blender Developer Tools" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="gltf-export-roundtrip — Examples — Blender Developer Tools" />
   <meta name="twitter:description" content="A sci-fi supply crate exported to glTF and re-imported, verifying the round-trip against the depsgraph-evaluated mesh within float tolerances. Positions, loop normals, box-mapped UVs, and per-triangle material bindings must all survive; the on-disk JSON proves the +Y-up conversion and the V-flipped UV layout." />
   <meta name="twitter:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/gltf-export-roundtrip-hero.webp" />
-  <meta name="twitter:image:alt" content="Two identical olive equipment crates with cyan light strips, both turned to show a side, labelled AUTHORED and ROUND-TRIP." />
+  <meta name="twitter:image:alt" content="One olive sci-fi supply crate with a cyan light strip, its right half traced by an amber wire cage of the re-imported glTF triangles that lands exactly on every bevel, rivet and vent slat." />
   <style>
     /* fonts are deployed by the landing build (docs/fonts/) */
     @font-face { font-family: 'Barlow Condensed'; font-weight: 600; font-display: swap;
@@ -268,8 +268,8 @@ <h1>gltf-export-roundtrip</h1>
     <p>A sci-fi supply crate exported to glTF and re-imported, verifying the round-trip against the depsgraph-evaluated mesh within float tolerances. Positions, loop normals, box-mapped UVs, and per-triangle material bindings must all survive; the on-disk JSON proves the +Y-up conversion and the V-flipped UV layout.</p>
   </header>
   <main id="main">
-    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: Two identical olive equipment crates with cyan light strips, both turned to show a side, labelled AUTHORED and ROUND-TRIP.">
-      <img src="../assets/gltf-export-roundtrip-hero.webp" alt="Two identical olive equipment crates with cyan light strips, both turned to show a side, labelled AUTHORED and ROUND-TRIP." width="1280" height="720" />
+    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: One olive sci-fi supply crate with a cyan light strip, its right half traced by an amber wire cage of the re-imported glTF triangles that lands exactly on every bevel, rivet and vent slat.">
+      <img src="../assets/gltf-export-roundtrip-hero.webp" alt="One olive sci-fi supply crate with a cyan light strip, its right half traced by an amber wire cage of the re-imported glTF triangles that lands exactly on every bevel, rivet and vent slat." 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> export_yup bakes (x, y, z) -&gt; (x, z, -y) into the vertex data with no node rotation (probed identical on 4.5.11 and 5.1.2); export_apply ships the evaluated mesh, not the base cage; exporter/importer RNA is guarded so a future kwarg rename fails loudly.</div>
@@ -278,14 +278,15 @@ <h1>gltf-export-roundtrip</h1>
       <button class="copy-btn" id="copyRun" type="button">Copy</button>
     </div>
     <section class="detail-section md">
-<p>A runnable example that builds a sci-fi supply crate — 35 beveled box shells with three material slots and box-mapped UVs — exports it with <code>bpy.ops.export_scene.gltf</code>, parses the file on disk, re-imports it, and verifies the whole round-trip against the depsgraph-evaluated mesh, following <a href="https://github.com/TMHSDigital/Blender-Developer-Tools/tree/main/skills/depsgraph-and-evaluated-data/SKILL.md"><code>depsgraph-and-evaluated-data</code></a> and <a href="https://github.com/TMHSDigital/Blender-Developer-Tools/tree/main/skills/headless-batch-scripting/SKILL.md"><code>headless-batch-scripting</code></a>.</p>
+<p>A runnable example that builds a sci-fi supply crate — 43 beveled box shells (body, lid with stiffening ribs, corner armour, carry handles over vent slats, latches, rivets, a status plate with glowing pips) with three material slots and box-mapped UVs — exports it with <code>bpy.ops.export_scene.gltf</code>, parses the file on disk, re-imports it, and verifies the whole round-trip against the depsgraph-evaluated mesh, following <a href="https://github.com/TMHSDigital/Blender-Developer-Tools/tree/main/skills/depsgraph-and-evaluated-data/SKILL.md"><code>depsgraph-and-evaluated-data</code></a> and <a href="https://github.com/TMHSDigital/Blender-Developer-Tools/tree/main/skills/headless-batch-scripting/SKILL.md"><code>headless-batch-scripting</code></a>.</p>
 <p><strong>Pipeline arc:</strong> modeling/LOD in <a href="https://github.com/TMHSDigital/Blender-Developer-Tools/tree/main/examples/lod-decimate-chain"><code>lod-decimate-chain</code></a>, weighting in <a href="https://github.com/TMHSDigital/Blender-Developer-Tools/tree/main/examples/vertex-weight-limit"><code>vertex-weight-limit</code></a>, export here.</p>
 <p><strong>What it witnesses:</strong> the interchange contracts AI-generated export code most often gets silently wrong.</p>
-<ul><li><strong>The +Y-up convention is baked into vertex data.</strong> glTF is +Y-up, Blender is +Z-up, and <code>export_yup=True</code> (the default) writes <code>(x, y, z) -&gt; (x, z, -y)</code> directly into the POSITION buffer — the node carries <strong>no</strong> rotation or scale. The check parses the <code>.gltf</code> JSON and asserts the accessor bounds equal the axis-converted evaluated bounding box, and that the node transform is absent. Exporting with <code>export_yup=False</code> ships raw Z-up data every engine displays lying on its back.</li><li><strong><code>export_apply=True</code> ships the evaluated mesh, not the base cage.</strong> The crate&#x27;s bevel modifier lives only in the depsgraph; with flat shading and UV seams the exporter splits exactly one vertex per evaluated loop (7,560), so the on-disk POSITION count is an exact witness. <code>export_apply=False</code> silently writes the 624-vertex cage.</li><li><strong>The round-trip is faithful.</strong> Re-imported positions (bit-exact here), loop normals (≤2e-4), box-mapped UVs (≤3e-5), and per-triangle material bindings all match the evaluated mesh. UVs are V-flipped on disk (glTF texture origin is top-left) and flipped back on import — both flips are proven by reading the <code>.bin</code> buffer directly.</li></ul>
+<ul><li><strong>The +Y-up convention is baked into vertex data.</strong> glTF is +Y-up, Blender is +Z-up, and <code>export_yup=True</code> (the default) writes <code>(x, y, z) -&gt; (x, z, -y)</code> directly into the POSITION buffer — the node carries <strong>no</strong> rotation or scale. The check parses the <code>.gltf</code> JSON and asserts the accessor bounds equal the axis-converted evaluated bounding box, and that the node transform is absent. Exporting with <code>export_yup=False</code> ships raw Z-up data every engine displays lying on its back.</li><li><strong><code>export_apply=True</code> ships the evaluated mesh, not the base cage.</strong> The crate&#x27;s bevel modifier lives only in the depsgraph; with flat shading and UV seams the exporter splits exactly one vertex per evaluated loop (9,288), so the on-disk POSITION count is an exact witness. <code>export_apply=False</code> silently writes the 344-vertex cage.</li><li><strong>The round-trip is faithful.</strong> Re-imported positions (bit-exact here), loop normals (≤2e-4), box-mapped UVs (≤3e-5), and per-triangle material bindings all match the evaluated mesh. UVs are V-flipped on disk (glTF texture origin is top-left) and flipped back on import — both flips are proven by reading the <code>.bin</code> buffer directly.</li></ul>
 <p><strong>Version witness (probed on Blender 4.5.11 LTS and 5.1.2):</strong> the operator signatures are byte-identical — 109 exporter properties, 20 importer properties, same defaults — and the exported JSON differs only in <code>asset.generator</code> (&quot;Khronos glTF Blender I/O v4.5.51&quot; vs &quot;v5.1.20&quot;). The example therefore runs identical kwargs on both versions and guards forward drift explicitly: every kwarg it passes must still exist in the operator&#x27;s RNA, so a future rename fails loudly instead of drifting silently. One genuine 5.x removal surfaced during authoring: <code>Mesh.calc_normals()</code> is gone (loop normals auto-compute on read) — calling it is itself a cross-version hazard, noted in the code.</p>
 <p>Two more authoring hazards are pinned in comments: exact face-plane coincidences between kit-bashed shells weld loops on export (the count check catches it), and <code>read_factory_settings</code> mid-check frees the original mesh — touching a freed RNA raises <code>ReferenceError</code>, so counts are captured before the wipe.</p>
-<p>The render stages the authored crate beside the actual re-imported one — same bevels, same materials carried through the file itself. If the axis conversion broke, the right twin would lie on its side; if the modifier contract broke, its silhouette would lose the rounded edges. Both twins are turned 22° off square so each shows a side and its corner armour; dead-on, the pair read as two flat front elevations. The re-imported object comes back in <code>QUATERNION</code> rotation mode, so the render path switches it to <code>XYZ</code> before turning it — presentation only, after every check has run.</p>
-<p>The render path gates framing through <code>gallery_framing.check_framing</code>. The helper returns 10, which is already a check code here, so the call site remaps a framing violation to 22.</p>
+<p>The render shows <strong>one</strong> crate. The solid crate is the authored one, rebuilt in place after the check. Laid over it is the actual re-imported mesh — the file&#x27;s own triangles — drawn as a thin amber wire cage (a render-only Weld + Wireframe display stack on the imported object) and masked to the right of a vertical cut, so the left half reads as the authored asset and the right half as the file&#x27;s geometry sitting on it. Neither object is moved: both keep the identity transform check 13 proved, and the camera does the turning. The cage lands on every bevel, rivet and vent slat only because the importer undid the +Y-up bake exactly and the file carried the evaluated (beveled) mesh. If the axis conversion broke, the cage would be rotated a quarter turn off the solid crate; a probe that re-applies that quarter turn to the imported object before rendering drops the cage through the floor and also fails the framing gate (bottom margin 0.000). If the modifier contract broke, the cage would trace square corners across the rounded ones.</p>
+<p>Presentation only, after every check has run: the authored crate&#x27;s bevel is baked into its display mesh (the asset-quality edge measure reads <code>Object.data</code>, which is still the square cage while the bevel lives in the modifier stack), and its paint and trim get a noise-mottled base colour and roughness. The exported file only ever carried the flat Principled values.</p>
+<p>The render path gates framing through <code>gallery_framing.check_framing</code> and the asset floors through <code>gallery_asset_quality.check_asset_quality</code> on the authored crate. Both helpers&#x27; codes (10, 11) are already check codes here, so the call site remaps them to 22 and 23.</p>
 <h2>Run</h2>
 <pre><code># Cheap correctness check (no render) — the CI check:
 blender --background --python gltf_export_roundtrip.py --
@@ -298,7 +299,7 @@ <h2>Run</h2>
 blender --background --python gltf_export_roundtrip.py -- --output crate.png --engine cycles</code></pre>
 <h2>Exit codes</h2>
 <p>Per-script sequential checks. <code>9</code> is a valid check code; there is no rule against it.</p>
-<div class="table-wrap"><table><thead><tr><th scope="col">Code</th><th scope="col">Meaning</th></tr></thead><tbody><tr><td>0</td><td>Success</td></tr><tr><td>1</td><td>Uncaught exception (FATAL wrapper)</td></tr><tr><td>2</td><td>argparse / usage</td></tr><tr><td>3</td><td>Exporter/importer RNA kwargs drifted</td></tr><tr><td>4</td><td>Base cage drifted from its closed form</td></tr><tr><td>5</td><td>Authored UVs drifted from the box-map closed form</td></tr><tr><td>6</td><td>Bevel produced no evaluated geometry</td></tr><tr><td>7</td><td>On-disk node/mesh/generator contract drifted</td></tr><tr><td>8</td><td>On-disk primitive/material binding count drifted</td></tr><tr><td>9</td><td>On-disk POSITION bounds ≠ axis-converted bbox (<code>--no-yup</code> lands here)</td></tr><tr><td>10</td><td>On-disk POSITION count ≠ evaluated loop count</td></tr><tr><td>11</td><td>On-disk UV V-flip failed</td></tr><tr><td>12</td><td>Re-import did not produce exactly one mesh</td></tr><tr><td>13</td><td>Re-imported object carries a transform</td></tr><tr><td>14</td><td>Material names drifted on re-import</td></tr><tr><td>15</td><td>Re-import vert count ≠ evaluated loop count</td></tr><tr><td>16</td><td>Round-trip position drift</td></tr><tr><td>17</td><td>Round-trip normal drift</td></tr><tr><td>18</td><td>Round-trip UV drift</td></tr><tr><td>19</td><td>Re-import triangle count drifted</td></tr><tr><td>20</td><td>Per-triangle material bindings drifted</td></tr><tr><td>21</td><td><code>--output</code> produced no file</td></tr><tr><td>22</td><td>Gallery framing violation (render path only; the helper&#x27;s 10, remapped)</td></tr></tbody></table></div>
+<div class="table-wrap"><table><thead><tr><th scope="col">Code</th><th scope="col">Meaning</th></tr></thead><tbody><tr><td>0</td><td>Success</td></tr><tr><td>1</td><td>Uncaught exception (FATAL wrapper)</td></tr><tr><td>2</td><td>argparse / usage</td></tr><tr><td>3</td><td>Exporter/importer RNA kwargs drifted</td></tr><tr><td>4</td><td>Base cage drifted from its closed form</td></tr><tr><td>5</td><td>Authored UVs drifted from the box-map closed form</td></tr><tr><td>6</td><td>Bevel produced no evaluated geometry</td></tr><tr><td>7</td><td>On-disk node/mesh/generator contract drifted</td></tr><tr><td>8</td><td>On-disk primitive/material binding count drifted</td></tr><tr><td>9</td><td>On-disk POSITION bounds ≠ axis-converted bbox (<code>--no-yup</code> lands here)</td></tr><tr><td>10</td><td>On-disk POSITION count ≠ evaluated loop count</td></tr><tr><td>11</td><td>On-disk UV V-flip failed</td></tr><tr><td>12</td><td>Re-import did not produce exactly one mesh</td></tr><tr><td>13</td><td>Re-imported object carries a transform</td></tr><tr><td>14</td><td>Material names drifted on re-import</td></tr><tr><td>15</td><td>Re-import vert count ≠ evaluated loop count</td></tr><tr><td>16</td><td>Round-trip position drift</td></tr><tr><td>17</td><td>Round-trip normal drift</td></tr><tr><td>18</td><td>Round-trip UV drift</td></tr><tr><td>19</td><td>Re-import triangle count drifted</td></tr><tr><td>20</td><td>Per-triangle material bindings drifted</td></tr><tr><td>21</td><td><code>--output</code> produced no file</td></tr><tr><td>22</td><td>Gallery framing violation (render path only; the helper&#x27;s 10, remapped)</td></tr><tr><td>23</td><td>Gallery asset-quality violation (render path only; the helper&#x27;s 11, remapped)</td></tr></tbody></table></div>
 <p>The <code>blender-smoke</code> workflow runs the check on Blender 5.2 LTS and 4.5 LTS (5.1 on the weekly cron, the <code>needs-5.1</code> PR label, or manual dispatch). Smoke does not pass <code>--output</code> or <code>--no-yup</code>.</p>
     </section>
     <section class="detail-section src">
@@ -354,6 +355,7 @@ <h2>Source</h2>
 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
 
 <span class="c"># ---------------------------------------------------------------------------</span>
 <span class="c"># Crate specification. Every part is an axis-aligned box, so every base-cage</span>
@@ -365,7 +367,7 @@ <h2>Source</h2>
 BEVEL_WIDTH = <span class="n">0.03</span>
 BEVEL_SEGMENTS = <span class="n">2</span>
 
-<span class="c"># (name, center, size, material) — 35 shells. Geometry rules that keep the</span>
+<span class="c"># (name, center, size, material) — 43 shells. Geometry rules that keep the</span>
 <span class="c"># exporter&#x27;s seam-splitting exact: no two shells share a face plane (exact</span>
 <span class="c"># float coincidences weld loops on export), interpenetration is fine, and the</span>
 <span class="c"># bevel width stays under half of every box dimension.</span>
@@ -397,6 +399,12 @@ <h2>Source</h2>
 <span class="c"># three status pips on the lid plate share the strip&#x27;s emissive language</span>
 PARTS += [(<span class="s">&quot;pip&quot;</span>, (sx * <span class="n">0.18</span>, <span class="n">0.0</span>, <span class="n">1.60</span>), (<span class="n">0.08</span>, <span class="n">0.08</span>, <span class="n">0.08</span>), GLOW)
           <span class="k">for</span> sx <span class="k">in</span> (-<span class="n">1</span>, <span class="n">0</span>, <span class="n">1</span>)]
+<span class="c"># vent slats stacked under each carry handle</span>
+PARTS += [(<span class="s">&quot;vent&quot;</span>, (sx * <span class="n">1.078</span>, <span class="n">0.0</span>, sz), (<span class="n">0.068</span>, <span class="n">0.70</span>, <span class="n">0.07</span>), TRIM)
+          <span class="k">for</span> sx <span class="k">in</span> (-<span class="n">1</span>, <span class="n">1</span>) <span class="k">for</span> sz <span class="k">in</span> (<span class="n">0.50</span>, <span class="n">0.62</span>, <span class="n">0.74</span>)]
+<span class="c"># stiffening ribs across the lid, either side of the status plate</span>
+PARTS += [(<span class="s">&quot;lid_rib&quot;</span>, (sx * <span class="n">0.75</span>, <span class="n">0.0</span>, <span class="n">1.572</span>), (<span class="n">0.10</span>, <span class="n">1.40</span>, <span class="n">0.066</span>), TRIM)
+          <span class="k">for</span> sx <span class="k">in</span> (-<span class="n">1</span>, <span class="n">1</span>)]
 
 UV_SCALE = <span class="n">0.4</span>          <span class="c"># box-map scale; authored UVs are a closed form of position</span>
 EXPORT_KWARGS = dict(
@@ -436,7 +444,7 @@ <h2>Source</h2>
 
 
 <span class="k">def</span> build_crate():
-    <span class="s">&quot;&quot;&quot;The supply crate: 35 beveled box shells, 3 material slots, box-mapped UVs.&quot;&quot;&quot;</span>
+    <span class="s">&quot;&quot;&quot;The supply crate: 43 beveled box shells, 3 material slots, box-mapped UVs.&quot;&quot;&quot;</span>
     me = bpy.data.meshes.new(<span class="s">&quot;SupplyCrate&quot;</span>)
     bm = bmesh.new()
     <span class="k">try</span>:
@@ -480,8 +488,8 @@ <h2>Source</h2>
             b.inputs[<span class="s">&quot;Emission Strength&quot;</span>].default_value = strength
         <span class="k">return</span> mat
     <span class="k">return</span> [
-        pbr(<span class="s">&quot;Paint&quot;</span>, (<span class="n">0.16</span>, <span class="n">0.18</span>, <span class="n">0.12</span>), <span class="n">0.15</span>, <span class="n">0.50</span>),
-        pbr(<span class="s">&quot;Trim&quot;</span>, (<span class="n">0.12</span>, <span class="n">0.13</span>, <span class="n">0.15</span>), <span class="n">0.90</span>, <span class="n">0.35</span>),
+        pbr(<span class="s">&quot;Paint&quot;</span>, (<span class="n">0.17</span>, <span class="n">0.20</span>, <span class="n">0.10</span>), <span class="n">0.10</span>, <span class="n">0.50</span>),
+        pbr(<span class="s">&quot;Trim&quot;</span>, (<span class="n">0.20</span>, <span class="n">0.21</span>, <span class="n">0.24</span>), <span class="n">0.75</span>, <span class="n">0.38</span>),
         pbr(<span class="s">&quot;Glow&quot;</span>, (<span class="n">0.02</span>, <span class="n">0.20</span>, <span class="n">0.25</span>), <span class="n">0.0</span>, <span class="n">0.40</span>,
             emission=(<span class="n">0.10</span>, <span class="n">0.75</span>, <span class="n">0.85</span>), strength=<span class="n">3.0</span>),
     ]
@@ -544,9 +552,10 @@ <h2>Source</h2>
 <span class="c"># glTF JSON + buffer reading (GLTF_SEPARATE layout).</span>
 <span class="c"># ---------------------------------------------------------------------------</span>
 <span class="k">def</span> read_gltf(path):
-    g = json.load(open(path))
-    blob = open(os.path.join(os.path.dirname(path),
-                             g[<span class="s">&quot;buffers&quot;</span>][<span class="n">0</span>][<span class="s">&quot;uri&quot;</span>]), <span class="s">&quot;rb&quot;</span>).read()
+    <span class="k">with</span> open(path, encoding=<span class="s">&quot;utf-8&quot;</span>) <span class="k">as</span> fh:
+        g = json.load(fh)
+    <span class="k">with</span> open(os.path.join(os.path.dirname(path), g[<span class="s">&quot;buffers&quot;</span>][<span class="n">0</span>][<span class="s">&quot;uri&quot;</span>]), <span class="s">&quot;rb&quot;</span>) <span class="k">as</span> fh:
+        blob = fh.read()
 
     <span class="k">def</span> accessor_floats(idx, ncomp):
         acc = g[<span class="s">&quot;accessors&quot;</span>][idx]
@@ -573,7 +582,7 @@ <h2>Source</h2>
         <span class="k">return</span> <span class="n">3</span>
 
     me = crate.data
-    <span class="c"># base cage is exactly the authored closed form: 35 boxes x 8 corners</span>
+    <span class="c"># base cage is exactly the authored closed form: 43 boxes x 8 corners</span>
     expect = sorted(key_of(c) <span class="k">for</span> _n, ce, s, _m <span class="k">in</span> PARTS <span class="k">for</span> c <span class="k">in</span> box_corners(ce, s))
     got = sorted(key_of(v.co) <span class="k">for</span> v <span class="k">in</span> me.vertices)
     <span class="k">if</span> got != expect:
@@ -802,48 +811,110 @@ <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>
 
 
+WIRE_THICKNESS = <span class="n">0.006</span>   <span class="c"># render-only overlay strip width (scene units)</span>
+SCAN_X = -<span class="n">0.10</span>           <span class="c"># object-space x where the overlay begins (render only)</span>
+
+
+<span class="k">def</span> wire_material():
+    <span class="s">&quot;&quot;&quot;Emissive amber strips, masked to the scanned side of SCAN_X.
+
+    The mask reads Object texture coordinates of the re-imported object,
+    which carries an identity transform (check 13) — so the cut sits at the
+    same place on both crates only because nothing moved them.
+    &quot;&quot;&quot;</span>
+    mat = bpy.data.materials.new(<span class="s">&quot;ScanWire&quot;</span>)
+    mat.use_nodes = <span class="k">True</span>
+    nt = mat.node_tree
+    <span class="k">for</span> n <span class="k">in</span> list(nt.nodes):
+        nt.nodes.remove(n)
+    out = nt.nodes.new(<span class="s">&quot;ShaderNodeOutputMaterial&quot;</span>)
+    emit = nt.nodes.new(<span class="s">&quot;ShaderNodeEmission&quot;</span>)
+    emit.inputs[<span class="s">&quot;Color&quot;</span>].default_value = (<span class="n">1.0</span>, <span class="n">0.36</span>, <span class="n">0.05</span>, <span class="n">1.0</span>)
+    emit.inputs[<span class="s">&quot;Strength&quot;</span>].default_value = <span class="n">1.3</span>
+    clear = nt.nodes.new(<span class="s">&quot;ShaderNodeBsdfTransparent&quot;</span>)
+    tc = nt.nodes.new(<span class="s">&quot;ShaderNodeTexCoord&quot;</span>)
+    sep = nt.nodes.new(<span class="s">&quot;ShaderNodeSeparateXYZ&quot;</span>)
+    gt = nt.nodes.new(<span class="s">&quot;ShaderNodeMath&quot;</span>)
+    gt.operation = <span class="s">&#x27;GREATER_THAN&#x27;</span>
+    gt.inputs[<span class="n">1</span>].default_value = SCAN_X
+    mix = nt.nodes.new(<span class="s">&quot;ShaderNodeMixShader&quot;</span>)
+    nt.links.new(tc.outputs[<span class="s">&quot;Object&quot;</span>], sep.inputs[<span class="n">0</span>])
+    nt.links.new(sep.outputs[<span class="s">&quot;X&quot;</span>], gt.inputs[<span class="n">0</span>])
+    nt.links.new(gt.outputs[<span class="n">0</span>], mix.inputs[<span class="s">&quot;Fac&quot;</span>])
+    nt.links.new(clear.outputs[<span class="n">0</span>], mix.inputs[<span class="n">1</span>])
+    nt.links.new(emit.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">return</span> mat
+
+
+<span class="k">def</span> weather(mat, scale, amount):
+    <span class="s">&quot;&quot;&quot;Render-only surface breakup: noise-mottled base color and roughness.
+
+    Applied to the authored crate&#x27;s display materials after every check has
+    run; the exported file only ever carried the flat Principled values.
+    &quot;&quot;&quot;</span>
+    nt = mat.node_tree
+    b = nt.nodes[<span class="s">&quot;Principled BSDF&quot;</span>]
+    base = tuple(b.inputs[<span class="s">&quot;Base Color&quot;</span>].default_value)
+    rough = b.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value
+    noise = nt.nodes.new(<span class="s">&quot;ShaderNodeTexNoise&quot;</span>)
+    noise.inputs[<span class="s">&quot;Scale&quot;</span>].default_value = scale
+    noise.inputs[<span class="s">&quot;Detail&quot;</span>].default_value = <span class="n">6.0</span>
+    ramp = nt.nodes.new(<span class="s">&quot;ShaderNodeValToRGB&quot;</span>)
+    ramp.color_ramp.elements[<span class="n">0</span>].position = <span class="n">0.35</span>
+    ramp.color_ramp.elements[<span class="n">1</span>].position = <span class="n">0.70</span>
+    ramp.color_ramp.elements[<span class="n">0</span>].color = tuple(c * (<span class="n">1.0</span> - amount) <span class="k">for</span> c <span class="k">in</span> base[:<span class="n">3</span>]) + (<span class="n">1.0</span>,)
+    ramp.color_ramp.elements[<span class="n">1</span>].color = tuple(min(<span class="n">1.0</span>, c * (<span class="n">1.0</span> + amount)) <span class="k">for</span> c <span class="k">in</span> base[:<span class="n">3</span>]) + (<span class="n">1.0</span>,)
+    nt.links.new(noise.outputs[<span class="s">&quot;Fac&quot;</span>], ramp.inputs[<span class="s">&quot;Fac&quot;</span>])
+    nt.links.new(ramp.outputs[<span class="s">&quot;Color&quot;</span>], b.inputs[<span class="s">&quot;Base Color&quot;</span>])
+    rmap = nt.nodes.new(<span class="s">&quot;ShaderNodeMapRange&quot;</span>)
+    rmap.inputs[<span class="s">&quot;To Min&quot;</span>].default_value = rough - <span class="n">0.12</span>
+    rmap.inputs[<span class="s">&quot;To Max&quot;</span>].default_value = rough + <span class="n">0.15</span>
+    nt.links.new(noise.outputs[<span class="s">&quot;Fac&quot;</span>], rmap.inputs[<span class="s">&quot;Value&quot;</span>])
+    nt.links.new(rmap.outputs[<span class="s">&quot;Result&quot;</span>], b.inputs[<span class="s">&quot;Roughness&quot;</span>])
+
+
 <span class="k">def</span> render_still(authored, roundtrip, path, engine):
     scene = bpy.context.scene
 
-    <span class="c"># the authored twin keeps its materials; the re-imported twin renders with</span>
-    <span class="c"># whatever the file carried back — the same look through the format itself</span>
-    <span class="c"># turned a quarter off square so each crate shows a side and its corner</span>
-    <span class="c"># guards read as solid; dead-on, the pair was two flat front elevations</span>
-    authored.location.x = -<span class="n">1.35</span>
-    roundtrip.location.x = <span class="n">1.35</span>
-    <span class="c"># the importer leaves objects in QUATERNION mode, where rotation_euler</span>
-    <span class="c"># is ignored</span>
-    <span class="k">for</span> ob <span class="k">in</span> (authored, roundtrip):
-        ob.rotation_mode = <span class="s">&#x27;XYZ&#x27;</span>
-        ob.rotation_euler.z = math.radians(-<span class="n">22.0</span>)
-
-    pm = bpy.data.materials.new(<span class="s">&quot;PlaqueMetal&quot;</span>)
-    pm.use_nodes = <span class="k">True</span>
-    pb = pm.node_tree.nodes[<span class="s">&quot;Principled BSDF&quot;</span>]
-    <span class="c"># diffuse light-grey, not metal: the AUTHORED/ROUND-TRIP labels are the</span>
-    <span class="c"># render&#x27;s argument and must survive thumbnail scale on the dark floor</span>
-    pb.inputs[<span class="s">&quot;Base Color&quot;</span>].default_value = (<span class="n">0.42</span>, <span class="n">0.44</span>, <span class="n">0.48</span>, <span class="n">1.0</span>)
-    pb.inputs[<span class="s">&quot;Metallic&quot;</span>].default_value = <span class="n">0.2</span>
-    pb.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.6</span>
-
-    <span class="k">def</span> plaque(text, x):
-        cu = bpy.data.curves.new(<span class="s">&quot;Plaque&quot;</span>, <span class="s">&#x27;FONT&#x27;</span>)
-        cu.body = text
-        cu.align_x = <span class="s">&#x27;CENTER&#x27;</span>
-        cu.size = <span class="n">0.30</span>
-        cu.extrude = <span class="n">0.008</span>
-        ob = bpy.data.objects.new(<span class="s">&quot;Plaque&quot;</span>, cu)
-        ob.location = (x, -<span class="n">1.55</span>, <span class="n">0.01</span>)
-        ob.data.materials.append(pm)
-        scene.collection.objects.link(ob)
-        <span class="k">return</span> ob
-
-    plaques = [plaque(<span class="s">&quot;AUTHORED&quot;</span>, -<span class="n">1.35</span>), plaque(<span class="s">&quot;ROUND-TRIP&quot;</span>, <span class="n">1.35</span>)]
+    <span class="c"># Neither crate is moved: both sit at the identity transform the check</span>
+    <span class="c"># proved for the re-import (check 13), and the camera does the turning.</span>
+    <span class="c"># The re-imported mesh — the file&#x27;s own triangles — is drawn as a thin</span>
+    <span class="c"># amber wire cage over the authored crate. It lands on every bevel only</span>
+    <span class="c"># because the import undid the +Y-up bake exactly; a broken axis</span>
+    <span class="c"># conversion would stand the cage on its back beside a solid crate.</span>
+    authored.name = <span class="s">&quot;Crate.Authored&quot;</span>
+    roundtrip.name = <span class="s">&quot;Crate.RoundTrip&quot;</span>
+    <span class="c"># Bake the authored bevel into the display mesh: the asset-quality edge</span>
+    <span class="c"># measure reads Object.data, which is the square-cornered cage while the</span>
+    <span class="c"># bevel still lives in the modifier stack.</span>
+    deps = bpy.context.evaluated_depsgraph_get()
+    baked = bpy.data.meshes.new_from_object(authored.evaluated_get(deps))
+    authored.modifiers.clear()
+    authored.data = baked
+    authored.data.name = <span class="s">&quot;Crate.Authored&quot;</span>
+    <span class="k">for</span> mat <span class="k">in</span> authored.data.materials:
+        <span class="k">if</span> mat.name.startswith(<span class="s">&quot;Paint&quot;</span>):
+            weather(mat, <span class="n">7.0</span>, <span class="n">0.20</span>)
+        <span class="k">elif</span> mat.name.startswith(<span class="s">&quot;Trim&quot;</span>):
+            weather(mat, <span class="n">14.0</span>, <span class="n">0.35</span>)
+    wire = wire_material()
+    <span class="k">for</span> i <span class="k">in</span> range(len(roundtrip.data.materials)):
+        roundtrip.data.materials[i] = wire
+    <span class="c"># glTF splits every loop into its own vertex; weld the display copy so</span>
+    <span class="c"># the frame strips run along shared edges instead of doubling up</span>
+    weld = roundtrip.modifiers.new(<span class="s">&quot;DisplayWeld&quot;</span>, <span class="s">&#x27;WELD&#x27;</span>)
+    weld.merge_threshold = <span class="n">1e-5</span>
+    wf = roundtrip.modifiers.new(<span class="s">&quot;DisplayWire&quot;</span>, <span class="s">&#x27;WIREFRAME&#x27;</span>)
+    wf.thickness = WIRE_THICKNESS
+    wf.offset = <span class="n">0.0</span>
+    wf.use_even_offset = <span class="k">True</span>
+    wf.use_boundary = <span class="k">True</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">60.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">30.0</span>)
         bm.to_mesh(floor_me)
     <span class="k">finally</span>:
         bm.free()
@@ -856,7 +927,7 @@ <h2>Source</h2>
     floor = bpy.data.objects.new(<span class="s">&quot;Floor&quot;</span>, floor_me)
     scene.collection.objects.link(floor)
     wall = bpy.data.objects.new(<span class="s">&quot;Wall&quot;</span>, floor_me.copy())
-    wall.location = (<span class="n">0.0</span>, <span class="n">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.radians(<span class="n">90</span>), <span class="n">0.0</span>, <span class="n">0.0</span>)
     scene.collection.objects.link(wall)
 
@@ -875,18 +946,19 @@ <h2>Source</h2>
 
     <span class="c"># shaped warm 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">560.0</span>, <span class="n">4.5</span>, (<span class="n">1.0</span>, <span class="n">0.96</span>, <span class="n">0.9</span>), (<span class="n">48</span>, <span class="n">0</span>, -<span class="n">38</span>))
-    light(<span class="s">&quot;Fill&quot;</span>, (<span class="n">5.0</span>, -<span class="n">4.0</span>, <span class="n">3.0</span>), <span class="n">100.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;Rim&quot;</span>, (<span class="n">0.5</span>, <span class="n">4.5</span>, <span class="n">5.0</span>), <span class="n">360.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">175</span>))
-    light(<span class="s">&quot;Wedge&quot;</span>, (<span class="n">2.5</span>, <span class="n">3.5</span>, <span class="n">4.2</span>), <span class="n">460.0</span>, <span class="n">5.5</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">195</span>))
+    light(<span class="s">&quot;Key&quot;</span>, (-<span class="n">4.0</span>, -<span class="n">5.0</span>, <span class="n">6.0</span>), <span class="n">520.0</span>, <span class="n">4.5</span>, (<span class="n">1.0</span>, <span class="n">0.96</span>, <span class="n">0.9</span>), (<span class="n">48</span>, <span class="n">0</span>, -<span class="n">38</span>))
+    light(<span class="s">&quot;Fill&quot;</span>, (<span class="n">5.0</span>, -<span class="n">4.0</span>, <span class="n">3.0</span>), <span class="n">90.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;Rim&quot;</span>, (<span class="n">0.5</span>, <span class="n">4.5</span>, <span class="n">5.0</span>), <span class="n">320.0</span>, <span class="n">4.0</span>, (<span class="n">0.6</span>, <span class="n">0.78</span>, <span class="n">1.0</span>), (-<span class="n">55</span>, <span class="n">0</span>, <span class="n">175</span>))
+    light(<span class="s">&quot;Wedge&quot;</span>, (<span class="n">2.0</span>, <span class="n">3.5</span>, <span class="n">4.2</span>), <span class="n">420.0</span>, <span class="n">5.5</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">195</span>))
 
     cam_data = bpy.data.cameras.new(<span class="s">&quot;Cam&quot;</span>)
-    cam_data.lens = <span class="n">53.0</span>
+    cam_data.lens = <span class="n">50.0</span>
     cam = bpy.data.objects.new(<span class="s">&quot;Cam&quot;</span>, cam_data)
-    cam.location = (<span class="n">0.0</span>, -<span class="n">8.9</span>, <span class="n">3.3</span>)
+    yaw = math.radians(CAM_YAW)
+    cam.location = (CAM_DIST * math.sin(yaw), -CAM_DIST * math.cos(yaw), CAM_Z)
     scene.collection.objects.link(cam)
     target = bpy.data.objects.new(<span class="s">&quot;Aim&quot;</span>, <span class="k">None</span>)
-    target.location = (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.75</span>)
+    target.location = (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.66</span>)
     scene.collection.objects.link(target)
     con = cam.constraints.new(<span class="s">&#x27;TRACK_TO&#x27;</span>)
     con.target = target
@@ -904,24 +976,32 @@ <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 wash the olive drab and teal glow toward pastel</span>
+    <span class="c"># AgX would wash the olive drab, teal glow and amber cage toward pastel</span>
     <span class="c"># (docs/VISUAL-STYLE.md)</span>
     scene.view_settings.view_transform = <span class="s">&#x27;Standard&#x27;</span>
+    bpy.context.view_layer.update()
     <span class="c"># Layer 1 framing gate (silhouette matte), before the beauty render so a</span>
     <span class="c"># defective composition ships no artifact. The helper returns 10, which is</span>
     <span class="c"># a check code here (POSITION count), so the call site remaps it to 22.</span>
     fcode = gallery_framing.check_framing(
-        scene, cam,
-        hero=[authored, roundtrip],
-        elements=[authored, roundtrip] + plaques,
-        stage=[floor, wall],
-    )
+        scene, cam, hero=[authored], elements=[authored, roundtrip],
+        stage=[floor, wall])
     <span class="k">if</span> fcode:
         <span class="k">return</span> <span class="n">22</span>
+    <span class="c"># asset-quality floors on the authored crate; its 11 is also a check</span>
+    <span class="c"># code here (UV V-flip), so the call site remaps it to 23</span>
+    <span class="k">if</span> gallery_asset_quality.check_asset_quality(scene, cam, hero=[authored],
+                                                 stage=[floor, wall]):
+        <span class="k">return</span> <span class="n">23</span>
     bpy.ops.render.render(write_still=<span class="k">True</span>)
     <span class="k">return</span> <span class="n">0</span> <span class="k">if</span> os.path.exists(path) <span class="k">and</span> os.path.getsize(path) &gt; <span class="n">0</span> <span class="k">else</span> <span class="n">21</span>
 
 
+CAM_YAW = <span class="n">34.0</span>     <span class="c"># degrees the camera orbits off the crate&#x27;s front</span>
+CAM_DIST = <span class="n">6.4</span>
+CAM_Z = <span class="n">3.0</span>
+
+
 <span class="k">def</span> main():
     argv = sys.argv[sys.argv.index(<span class="s">&quot;--&quot;</span>) + <span class="n">1</span>:] <span class="k">if</span> <span class="s">&quot;--&quot;</span> <span class="k">in</span> sys.argv <span class="k">else</span> []
     p = argparse.ArgumentParser()
@@ -945,7 +1025,8 @@ <h2>Source</h2>
 
     <span class="k">if</span> args.output:
         <span class="c"># the re-imported crate is still in the file (check wiped and</span>
-        <span class="c"># re-imported); build an authored twin beside it</span>
+        <span class="c"># re-imported); rebuild the authored crate in the same place so the</span>
+        <span class="c"># file&#x27;s geometry can be laid over it</span>
         roundtrip = [o <span class="k">for</span> o <span class="k">in</span> bpy.data.objects <span class="k">if</span> o.type == <span class="s">&#x27;MESH&#x27;</span>][<span class="n">0</span>]
         authored = build_crate()
         <span class="k">for</span> m <span class="k">in</span> make_materials():
@@ -972,7 +1053,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/gltf-export-roundtrip-hero.webp" alt="Two identical olive equipment crates with cyan light strips, both turned to show a side, labelled AUTHORED and ROUND-TRIP." />
+    <img src="../assets/gltf-export-roundtrip-hero.webp" alt="One olive sci-fi supply crate with a cyan light strip, its right half traced by an amber wire cage of the re-imported glTF triangles that lands exactly on every bevel, rivet and vent slat." />
   </dialog>
   <footer>
     <div class="statusbar">
diff --git a/docs/gallery/index.html b/docs/gallery/index.html
index 00fdc052..3672f5e8 100644
--- a/docs/gallery/index.html
+++ b/docs/gallery/index.html
@@ -607,7 +607,7 @@ <h2><a href="vse-cut-list/">vse-cut-list</a></h2>
       </article>
       <article class="card" data-tags="export uv">
         <a class="card-media" href="gltf-export-roundtrip/" tabindex="-1" aria-hidden="true">
-          <img src="assets/gltf-export-roundtrip-hero.webp" alt="Two identical olive equipment crates with cyan light strips, both turned to show a side, labelled AUTHORED and ROUND-TRIP." loading="lazy" decoding="async" />
+          <img src="assets/gltf-export-roundtrip-hero.webp" alt="One olive sci-fi supply crate with a cyan light strip, its right half traced by an amber wire cage of the re-imported glTF triangles that lands exactly on every bevel, rivet and vent slat." loading="lazy" decoding="async" />
         </a>
         <div class="card-body">
           <h2><a href="gltf-export-roundtrip/">gltf-export-roundtrip</a></h2>
diff --git a/examples/gallery.json b/examples/gallery.json
index ca947b48..f3ada711 100644
--- a/examples/gallery.json
+++ b/examples/gallery.json
@@ -329,7 +329,7 @@
       "name": "gltf-export-roundtrip",
       "dir": "examples/gltf-export-roundtrip",
       "teaches": "A sci-fi supply crate exported to glTF and re-imported, verifying the round-trip against the depsgraph-evaluated mesh within float tolerances. Positions, loop normals, box-mapped UVs, and per-triangle material bindings must all survive; the on-disk JSON proves the +Y-up conversion and the V-flipped UV layout.",
-      "alt": "Two identical olive equipment crates with cyan light strips, both turned to show a side, labelled AUTHORED and ROUND-TRIP.",
+      "alt": "One olive sci-fi supply crate with a cyan light strip, its right half traced by an amber wire cage of the re-imported glTF triangles that lands exactly on every bevel, rivet and vent slat.",
       "witnessesFix": "export_yup bakes (x, y, z) -> (x, z, -y) into the vertex data with no node rotation (probed identical on 4.5.11 and 5.1.2); export_apply ships the evaluated mesh, not the base cage; exporter/importer RNA is guarded so a future kwarg rename fails loudly.",
       "hero": "docs/gallery/assets/gltf-export-roundtrip-hero.webp",
       "preview": "examples/gltf-export-roundtrip/preview.webp",
diff --git a/examples/gltf-export-roundtrip/README.md b/examples/gltf-export-roundtrip/README.md
index 8520b94b..71f1488f 100644
--- a/examples/gltf-export-roundtrip/README.md
+++ b/examples/gltf-export-roundtrip/README.md
@@ -1,7 +1,8 @@
 # glTF Export Round-Trip
 
-A runnable example that builds a sci-fi supply crate — 35 beveled box shells with
-three material slots and box-mapped UVs — exports it with
+A runnable example that builds a sci-fi supply crate — 43 beveled box shells (body, lid with
+stiffening ribs, corner armour, carry handles over vent slats, latches, rivets,
+a status plate with glowing pips) with three material slots and box-mapped UVs — exports it with
 `bpy.ops.export_scene.gltf`, parses the file on disk, re-imports it, and verifies
 the whole round-trip against the depsgraph-evaluated mesh, following
 [`depsgraph-and-evaluated-data`](../../skills/depsgraph-and-evaluated-data/SKILL.md)
@@ -22,9 +23,9 @@ often gets silently wrong.
   lying on its back.
 - **`export_apply=True` ships the evaluated mesh, not the base cage.** The
   crate's bevel modifier lives only in the depsgraph; with flat shading and UV
-  seams the exporter splits exactly one vertex per evaluated loop (7,560), so
+  seams the exporter splits exactly one vertex per evaluated loop (9,288), so
   the on-disk POSITION count is an exact witness. `export_apply=False` silently
-  writes the 624-vertex cage.
+  writes the 344-vertex cage.
 - **The round-trip is faithful.** Re-imported positions (bit-exact here), loop
   normals (≤2e-4), box-mapped UVs (≤3e-5), and per-triangle material bindings
   all match the evaluated mesh. UVs are V-flipped on disk (glTF texture origin
@@ -46,18 +47,31 @@ between kit-bashed shells weld loops on export (the count check catches it), and
 `read_factory_settings` mid-check frees the original mesh — touching a freed RNA
 raises `ReferenceError`, so counts are captured before the wipe.
 
-The render stages the authored crate beside the actual re-imported one — same
-bevels, same materials carried through the file itself. If the axis conversion
-broke, the right twin would lie on its side; if the modifier contract broke, its
-silhouette would lose the rounded edges. Both twins are turned 22° off
-square so each shows a side and its corner armour; dead-on, the pair read
-as two flat front elevations. The re-imported object comes back in
-`QUATERNION` rotation mode, so the render path switches it to `XYZ`
-before turning it — presentation only, after every check has run.
-
-The render path gates framing through `gallery_framing.check_framing`.
-The helper returns 10, which is already a check code here, so the call
-site remaps a framing violation to 22.
+The render shows **one** crate. The solid crate is the authored one, rebuilt
+in place after the check. Laid over it is the actual re-imported mesh — the
+file's own triangles — drawn as a thin amber wire cage (a render-only Weld +
+Wireframe display stack on the imported object) and masked to the right of a
+vertical cut, so the left half reads as the authored asset and the right half
+as the file's geometry sitting on it. Neither object is moved: both keep the
+identity transform check 13 proved, and the camera does the turning. The cage
+lands on every bevel, rivet and vent slat only because the importer undid the
++Y-up bake exactly and the file carried the evaluated (beveled) mesh. If the
+axis conversion broke, the cage would be rotated a quarter turn off the solid
+crate; a probe that re-applies that quarter turn to the imported object before
+rendering drops the cage through the floor and also fails the framing gate
+(bottom margin 0.000). If the modifier contract broke, the cage would trace
+square corners across the rounded ones.
+
+Presentation only, after every check has run: the authored crate's bevel is
+baked into its display mesh (the asset-quality edge measure reads
+`Object.data`, which is still the square cage while the bevel lives in the
+modifier stack), and its paint and trim get a noise-mottled base colour and
+roughness. The exported file only ever carried the flat Principled values.
+
+The render path gates framing through `gallery_framing.check_framing` and the
+asset floors through `gallery_asset_quality.check_asset_quality` on the
+authored crate. Both helpers' codes (10, 11) are already check codes here, so
+the call site remaps them to 22 and 23.
 
 ## Run
 
@@ -103,6 +117,7 @@ against it.
 | 20 | Per-triangle material bindings drifted |
 | 21 | `--output` produced no file |
 | 22 | Gallery framing violation (render path only; the helper's 10, remapped) |
+| 23 | Gallery asset-quality violation (render path only; the helper's 11, remapped) |
 
 The `blender-smoke` workflow runs the check on Blender 5.2 LTS and 4.5 LTS
 (5.1 on the weekly cron, the `needs-5.1` PR label, or manual dispatch).
diff --git a/examples/gltf-export-roundtrip/gltf_export_roundtrip.py b/examples/gltf-export-roundtrip/gltf_export_roundtrip.py
index b112f2f1..ed5a6a6c 100644
--- a/examples/gltf-export-roundtrip/gltf_export_roundtrip.py
+++ b/examples/gltf-export-roundtrip/gltf_export_roundtrip.py
@@ -45,6 +45,7 @@
 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
 
 # ---------------------------------------------------------------------------
 # Crate specification. Every part is an axis-aligned box, so every base-cage
@@ -56,7 +57,7 @@
 BEVEL_WIDTH = 0.03
 BEVEL_SEGMENTS = 2
 
-# (name, center, size, material) — 35 shells. Geometry rules that keep the
+# (name, center, size, material) — 43 shells. Geometry rules that keep the
 # exporter's seam-splitting exact: no two shells share a face plane (exact
 # float coincidences weld loops on export), interpenetration is fine, and the
 # bevel width stays under half of every box dimension.
@@ -88,6 +89,12 @@
 # three status pips on the lid plate share the strip's emissive language
 PARTS += [("pip", (sx * 0.18, 0.0, 1.60), (0.08, 0.08, 0.08), GLOW)
           for sx in (-1, 0, 1)]
+# vent slats stacked under each carry handle
+PARTS += [("vent", (sx * 1.078, 0.0, sz), (0.068, 0.70, 0.07), TRIM)
+          for sx in (-1, 1) for sz in (0.50, 0.62, 0.74)]
+# stiffening ribs across the lid, either side of the status plate
+PARTS += [("lid_rib", (sx * 0.75, 0.0, 1.572), (0.10, 1.40, 0.066), TRIM)
+          for sx in (-1, 1)]
 
 UV_SCALE = 0.4          # box-map scale; authored UVs are a closed form of position
 EXPORT_KWARGS = dict(
@@ -127,7 +134,7 @@ def boxmap_uv(co, normal):
 
 
 def build_crate():
-    """The supply crate: 35 beveled box shells, 3 material slots, box-mapped UVs."""
+    """The supply crate: 43 beveled box shells, 3 material slots, box-mapped UVs."""
     me = bpy.data.meshes.new("SupplyCrate")
     bm = bmesh.new()
     try:
@@ -171,8 +178,8 @@ def pbr(name, base, metallic, roughness, emission=None, strength=0.0):
             b.inputs["Emission Strength"].default_value = strength
         return mat
     return [
-        pbr("Paint", (0.16, 0.18, 0.12), 0.15, 0.50),
-        pbr("Trim", (0.12, 0.13, 0.15), 0.90, 0.35),
+        pbr("Paint", (0.17, 0.20, 0.10), 0.10, 0.50),
+        pbr("Trim", (0.20, 0.21, 0.24), 0.75, 0.38),
         pbr("Glow", (0.02, 0.20, 0.25), 0.0, 0.40,
             emission=(0.10, 0.75, 0.85), strength=3.0),
     ]
@@ -235,9 +242,10 @@ def candidates(m, p):
 # glTF JSON + buffer reading (GLTF_SEPARATE layout).
 # ---------------------------------------------------------------------------
 def read_gltf(path):
-    g = json.load(open(path))
-    blob = open(os.path.join(os.path.dirname(path),
-                             g["buffers"][0]["uri"]), "rb").read()
+    with open(path, encoding="utf-8") as fh:
+        g = json.load(fh)
+    with open(os.path.join(os.path.dirname(path), g["buffers"][0]["uri"]), "rb") as fh:
+        blob = fh.read()
 
     def accessor_floats(idx, ncomp):
         acc = g["accessors"][idx]
@@ -264,7 +272,7 @@ def check(crate, export_kwargs):
         return 3
 
     me = crate.data
-    # base cage is exactly the authored closed form: 35 boxes x 8 corners
+    # base cage is exactly the authored closed form: 43 boxes x 8 corners
     expect = sorted(key_of(c) for _n, ce, s, _m in PARTS for c in box_corners(ce, s))
     got = sorted(key_of(v.co) for v in me.vertices)
     if got != expect:
@@ -493,48 +501,110 @@ def eevee_engine_id():
     return 'BLENDER_EEVEE' if bpy.app.version >= (5, 0, 0) else 'BLENDER_EEVEE_NEXT'
 
 
+WIRE_THICKNESS = 0.006   # render-only overlay strip width (scene units)
+SCAN_X = -0.10           # object-space x where the overlay begins (render only)
+
+
+def wire_material():
+    """Emissive amber strips, masked to the scanned side of SCAN_X.
+
+    The mask reads Object texture coordinates of the re-imported object,
+    which carries an identity transform (check 13) — so the cut sits at the
+    same place on both crates only because nothing moved them.
+    """
+    mat = bpy.data.materials.new("ScanWire")
+    mat.use_nodes = True
+    nt = mat.node_tree
+    for n in list(nt.nodes):
+        nt.nodes.remove(n)
+    out = nt.nodes.new("ShaderNodeOutputMaterial")
+    emit = nt.nodes.new("ShaderNodeEmission")
+    emit.inputs["Color"].default_value = (1.0, 0.36, 0.05, 1.0)
+    emit.inputs["Strength"].default_value = 1.3
+    clear = nt.nodes.new("ShaderNodeBsdfTransparent")
+    tc = nt.nodes.new("ShaderNodeTexCoord")
+    sep = nt.nodes.new("ShaderNodeSeparateXYZ")
+    gt = nt.nodes.new("ShaderNodeMath")
+    gt.operation = 'GREATER_THAN'
+    gt.inputs[1].default_value = SCAN_X
+    mix = nt.nodes.new("ShaderNodeMixShader")
+    nt.links.new(tc.outputs["Object"], sep.inputs[0])
+    nt.links.new(sep.outputs["X"], gt.inputs[0])
+    nt.links.new(gt.outputs[0], mix.inputs["Fac"])
+    nt.links.new(clear.outputs[0], mix.inputs[1])
+    nt.links.new(emit.outputs[0], mix.inputs[2])
+    nt.links.new(mix.outputs[0], out.inputs["Surface"])
+    return mat
+
+
+def weather(mat, scale, amount):
+    """Render-only surface breakup: noise-mottled base color and roughness.
+
+    Applied to the authored crate's display materials after every check has
+    run; the exported file only ever carried the flat Principled values.
+    """
+    nt = mat.node_tree
+    b = nt.nodes["Principled BSDF"]
+    base = tuple(b.inputs["Base Color"].default_value)
+    rough = b.inputs["Roughness"].default_value
+    noise = nt.nodes.new("ShaderNodeTexNoise")
+    noise.inputs["Scale"].default_value = scale
+    noise.inputs["Detail"].default_value = 6.0
+    ramp = nt.nodes.new("ShaderNodeValToRGB")
+    ramp.color_ramp.elements[0].position = 0.35
+    ramp.color_ramp.elements[1].position = 0.70
+    ramp.color_ramp.elements[0].color = tuple(c * (1.0 - amount) for c in base[:3]) + (1.0,)
+    ramp.color_ramp.elements[1].color = tuple(min(1.0, c * (1.0 + amount)) for c in base[:3]) + (1.0,)
+    nt.links.new(noise.outputs["Fac"], ramp.inputs["Fac"])
+    nt.links.new(ramp.outputs["Color"], b.inputs["Base Color"])
+    rmap = nt.nodes.new("ShaderNodeMapRange")
+    rmap.inputs["To Min"].default_value = rough - 0.12
+    rmap.inputs["To Max"].default_value = rough + 0.15
+    nt.links.new(noise.outputs["Fac"], rmap.inputs["Value"])
+    nt.links.new(rmap.outputs["Result"], b.inputs["Roughness"])
+
+
 def render_still(authored, roundtrip, path, engine):
     scene = bpy.context.scene
 
-    # the authored twin keeps its materials; the re-imported twin renders with
-    # whatever the file carried back — the same look through the format itself
-    # turned a quarter off square so each crate shows a side and its corner
-    # guards read as solid; dead-on, the pair was two flat front elevations
-    authored.location.x = -1.35
-    roundtrip.location.x = 1.35
-    # the importer leaves objects in QUATERNION mode, where rotation_euler
-    # is ignored
-    for ob in (authored, roundtrip):
-        ob.rotation_mode = 'XYZ'
-        ob.rotation_euler.z = math.radians(-22.0)
-
-    pm = bpy.data.materials.new("PlaqueMetal")
-    pm.use_nodes = True
-    pb = pm.node_tree.nodes["Principled BSDF"]
-    # diffuse light-grey, not metal: the AUTHORED/ROUND-TRIP labels are the
-    # render's argument and must survive thumbnail scale on the dark floor
-    pb.inputs["Base Color"].default_value = (0.42, 0.44, 0.48, 1.0)
-    pb.inputs["Metallic"].default_value = 0.2
-    pb.inputs["Roughness"].default_value = 0.6
-
-    def plaque(text, x):
-        cu = bpy.data.curves.new("Plaque", 'FONT')
-        cu.body = text
-        cu.align_x = 'CENTER'
-        cu.size = 0.30
-        cu.extrude = 0.008
-        ob = bpy.data.objects.new("Plaque", cu)
-        ob.location = (x, -1.55, 0.01)
-        ob.data.materials.append(pm)
-        scene.collection.objects.link(ob)
-        return ob
-
-    plaques = [plaque("AUTHORED", -1.35), plaque("ROUND-TRIP", 1.35)]
+    # Neither crate is moved: both sit at the identity transform the check
+    # proved for the re-import (check 13), and the camera does the turning.
+    # The re-imported mesh — the file's own triangles — is drawn as a thin
+    # amber wire cage over the authored crate. It lands on every bevel only
+    # because the import undid the +Y-up bake exactly; a broken axis
+    # conversion would stand the cage on its back beside a solid crate.
+    authored.name = "Crate.Authored"
+    roundtrip.name = "Crate.RoundTrip"
+    # Bake the authored bevel into the display mesh: the asset-quality edge
+    # measure reads Object.data, which is the square-cornered cage while the
+    # bevel still lives in the modifier stack.
+    deps = bpy.context.evaluated_depsgraph_get()
+    baked = bpy.data.meshes.new_from_object(authored.evaluated_get(deps))
+    authored.modifiers.clear()
+    authored.data = baked
+    authored.data.name = "Crate.Authored"
+    for mat in authored.data.materials:
+        if mat.name.startswith("Paint"):
+            weather(mat, 7.0, 0.20)
+        elif mat.name.startswith("Trim"):
+            weather(mat, 14.0, 0.35)
+    wire = wire_material()
+    for i in range(len(roundtrip.data.materials)):
+        roundtrip.data.materials[i] = wire
+    # glTF splits every loop into its own vertex; weld the display copy so
+    # the frame strips run along shared edges instead of doubling up
+    weld = roundtrip.modifiers.new("DisplayWeld", 'WELD')
+    weld.merge_threshold = 1e-5
+    wf = roundtrip.modifiers.new("DisplayWire", 'WIREFRAME')
+    wf.thickness = WIRE_THICKNESS
+    wf.offset = 0.0
+    wf.use_even_offset = True
+    wf.use_boundary = True
 
     floor_me = bpy.data.meshes.new("Floor")
     bm = bmesh.new()
     try:
-        bmesh.ops.create_grid(bm, x_segments=1, y_segments=1, size=60.0)
+        bmesh.ops.create_grid(bm, x_segments=1, y_segments=1, size=30.0)
         bm.to_mesh(floor_me)
     finally:
         bm.free()
@@ -547,7 +617,7 @@ def plaque(text, x):
     floor = bpy.data.objects.new("Floor", floor_me)
     scene.collection.objects.link(floor)
     wall = bpy.data.objects.new("Wall", floor_me.copy())
-    wall.location = (0.0, 9.0, 0.0)
+    wall.location = (0.0, 8.0, 0.0)
     wall.rotation_euler = (math.radians(90), 0.0, 0.0)
     scene.collection.objects.link(wall)
 
@@ -566,18 +636,19 @@ def light(name, loc, energy, size, col, rot):
 
     # shaped warm key, faint cool fill, cool rim, warm wedge on the back wall
     # (docs/VISUAL-STYLE.md)
-    light("Key", (-4.0, -5.0, 6.0), 560.0, 4.5, (1.0, 0.96, 0.9), (48, 0, -38))
-    light("Fill", (5.0, -4.0, 3.0), 100.0, 9.0, (0.75, 0.85, 1.0), (62, 0, 50))
-    light("Rim", (0.5, 4.5, 5.0), 360.0, 4.0, (0.6, 0.78, 1.0), (-55, 0, 175))
-    light("Wedge", (2.5, 3.5, 4.2), 460.0, 5.5, (1.0, 0.76, 0.5), (-72, 0, 195))
+    light("Key", (-4.0, -5.0, 6.0), 520.0, 4.5, (1.0, 0.96, 0.9), (48, 0, -38))
+    light("Fill", (5.0, -4.0, 3.0), 90.0, 9.0, (0.75, 0.85, 1.0), (62, 0, 50))
+    light("Rim", (0.5, 4.5, 5.0), 320.0, 4.0, (0.6, 0.78, 1.0), (-55, 0, 175))
+    light("Wedge", (2.0, 3.5, 4.2), 420.0, 5.5, (1.0, 0.76, 0.5), (-72, 0, 195))
 
     cam_data = bpy.data.cameras.new("Cam")
-    cam_data.lens = 53.0
+    cam_data.lens = 50.0
     cam = bpy.data.objects.new("Cam", cam_data)
-    cam.location = (0.0, -8.9, 3.3)
+    yaw = math.radians(CAM_YAW)
+    cam.location = (CAM_DIST * math.sin(yaw), -CAM_DIST * math.cos(yaw), CAM_Z)
     scene.collection.objects.link(cam)
     target = bpy.data.objects.new("Aim", None)
-    target.location = (0.0, 0.0, 0.75)
+    target.location = (0.0, 0.0, 0.66)
     scene.collection.objects.link(target)
     con = cam.constraints.new('TRACK_TO')
     con.target = target
@@ -595,24 +666,32 @@ 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 wash the olive drab and teal glow toward pastel
+    # AgX would wash the olive drab, teal glow and amber cage toward pastel
     # (docs/VISUAL-STYLE.md)
     scene.view_settings.view_transform = 'Standard'
+    bpy.context.view_layer.update()
     # Layer 1 framing gate (silhouette matte), before the beauty render so a
     # defective composition ships no artifact. The helper returns 10, which is
     # a check code here (POSITION count), so the call site remaps it to 22.
     fcode = gallery_framing.check_framing(
-        scene, cam,
-        hero=[authored, roundtrip],
-        elements=[authored, roundtrip] + plaques,
-        stage=[floor, wall],
-    )
+        scene, cam, hero=[authored], elements=[authored, roundtrip],
+        stage=[floor, wall])
     if fcode:
         return 22
+    # asset-quality floors on the authored crate; its 11 is also a check
+    # code here (UV V-flip), so the call site remaps it to 23
+    if gallery_asset_quality.check_asset_quality(scene, cam, hero=[authored],
+                                                 stage=[floor, wall]):
+        return 23
     bpy.ops.render.render(write_still=True)
     return 0 if os.path.exists(path) and os.path.getsize(path) > 0 else 21
 
 
+CAM_YAW = 34.0     # degrees the camera orbits off the crate's front
+CAM_DIST = 6.4
+CAM_Z = 3.0
+
+
 def main():
     argv = sys.argv[sys.argv.index("--") + 1:] if "--" in sys.argv else []
     p = argparse.ArgumentParser()
@@ -636,7 +715,8 @@ def main():
 
     if args.output:
         # the re-imported crate is still in the file (check wiped and
-        # re-imported); build an authored twin beside it
+        # re-imported); rebuild the authored crate in the same place so the
+        # file's geometry can be laid over it
         roundtrip = [o for o in bpy.data.objects if o.type == 'MESH'][0]
         authored = build_crate()
         for m in make_materials():
diff --git a/examples/gltf-export-roundtrip/preview.webp b/examples/gltf-export-roundtrip/preview.webp
index 672e8e26..650a0b32 100644
Binary files a/examples/gltf-export-roundtrip/preview.webp and b/examples/gltf-export-roundtrip/preview.webp differ
diff --git a/scripts/asset_sheet.py b/scripts/asset_sheet.py
index b69ec069..17894159 100644
--- a/scripts/asset_sheet.py
+++ b/scripts/asset_sheet.py
@@ -72,6 +72,7 @@
     "prop-origin-transform": (r"^(Pedestal|Conduit)\.Keep$", None),
     "gltf-skin-roundtrip": (r"^ScorpionAuthored$", None),
     "mesh-hygiene-audit": (r"^Valve\.", None),
+    "gltf-export-roundtrip": (r"^Crate\.Authored$", None),
 }
 
 _REF_LINE = re.compile(r"Asset-sheet gate.*?reference set — currently (.+?) — rendered", re.S)