diff --git a/README.md b/README.md
index ba31580a..f6ef1fa9 100644
--- a/README.md
+++ b/README.md
@@ -408,7 +408,7 @@ lifting and flaring the rim — authored through `shape_key_add` / `key_blocks`
 </tr>
 <tr>
 <td width="46%" valign="middle">
-<a href="examples/curve-bevel-arc/"><img src="examples/curve-bevel-arc/preview.webp" alt="Curve bevel arc: a rose beveled Bezier semicircle tube resting on a dark studio floor, both filled end caps facing the camera" /></a>
+<a href="examples/curve-bevel-arc/"><img src="examples/curve-bevel-arc/preview.webp" alt="Curve bevel arc: a red horseshoe magnet built from one beveled Bezier curve, its filled end caps turned to the camera as steel pole faces, iron filings arcing between the poles and Bezier-wire paper clips clinging to them" /></a>
 </td>
 <td valign="middle">
 
@@ -416,8 +416,9 @@ lifting and flaring the rim — authored through `shape_key_add` / `key_blocks`
 
 A beveled Bezier semicircle authored on `bpy.types.Curve` — `splines.new('BEZIER')`,
 `bezier_points`, `bevel_depth`, `use_fill_caps` — so the curve renders as a solid tube
-without a prior mesh conversion. Asserts eight points, `bevel_depth == 0.15`, and
-evaluated topology 1044 verts / 1028 faces.
+without a prior mesh conversion — staged as a horseshoe magnet whose capped ends
+are the pole faces. Asserts eight points, `bevel_depth == 0.15`, and evaluated
+topology 1044 verts / 1028 faces.
 
 </td>
 </tr>
diff --git a/docs/gallery/asset-sheets/curve-bevel-arc.webp b/docs/gallery/asset-sheets/curve-bevel-arc.webp
new file mode 100644
index 00000000..7e2cae4e
Binary files /dev/null and b/docs/gallery/asset-sheets/curve-bevel-arc.webp differ
diff --git a/docs/gallery/assets/curve-bevel-arc-hero.webp b/docs/gallery/assets/curve-bevel-arc-hero.webp
index 5dc56770..b1b44a61 100644
Binary files a/docs/gallery/assets/curve-bevel-arc-hero.webp and b/docs/gallery/assets/curve-bevel-arc-hero.webp differ
diff --git a/docs/gallery/contact-sheets/curve-bevel-arc-contact-sheet.webp b/docs/gallery/contact-sheets/curve-bevel-arc-contact-sheet.webp
index 3d84fbb0..1f6ed81c 100644
Binary files a/docs/gallery/contact-sheets/curve-bevel-arc-contact-sheet.webp and b/docs/gallery/contact-sheets/curve-bevel-arc-contact-sheet.webp differ
diff --git a/docs/gallery/curve-bevel-arc/index.html b/docs/gallery/curve-bevel-arc/index.html
index c3f7ac34..73eaeb08 100644
--- a/docs/gallery/curve-bevel-arc/index.html
+++ b/docs/gallery/curve-bevel-arc/index.html
@@ -16,13 +16,13 @@
   <meta property="og:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/curve-bevel-arc-hero.webp" />
   <meta property="og:image:width" content="1280" />
   <meta property="og:image:height" content="720" />
-  <meta property="og:image:alt" content="A magenta beveled curve tube lying in a semicircle on a dark floor, both filled end caps facing the camera." />
+  <meta property="og:image:alt" content="A red horseshoe magnet made of one beveled Bezier curve on a dark floor, its filled end caps facing the camera as steel pole faces, iron filings arcing between them." />
   <meta property="og:site_name" content="Blender Developer Tools" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="curve-bevel-arc — Examples — Blender Developer Tools" />
   <meta name="twitter:description" content="A beveled Bezier semicircle authored on bpy.types.Curve — splines.new(&#x27;BEZIER&#x27;), bezier_points, bevel_depth, use_fill_caps — so the curve renders as a solid tube without a prior mesh conversion." />
   <meta name="twitter:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/curve-bevel-arc-hero.webp" />
-  <meta name="twitter:image:alt" content="A magenta beveled curve tube lying in a semicircle on a dark floor, both filled end caps facing the camera." />
+  <meta name="twitter:image:alt" content="A red horseshoe magnet made of one beveled Bezier curve on a dark floor, its filled end caps facing the camera as steel pole faces, iron filings arcing between them." />
   <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>curve-bevel-arc</h1>
     <p>A beveled Bezier semicircle authored on bpy.types.Curve — splines.new(&#x27;BEZIER&#x27;), bezier_points, bevel_depth, use_fill_caps — so the curve renders as a solid tube without a prior mesh conversion.</p>
   </header>
   <main id="main">
-    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: A magenta beveled curve tube lying in a semicircle on a dark floor, both filled end caps facing the camera.">
-      <img src="../assets/curve-bevel-arc-hero.webp" alt="A magenta beveled curve tube lying in a semicircle on a dark floor, both filled end caps facing the camera." width="1280" height="720" />
+    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: A red horseshoe magnet made of one beveled Bezier curve on a dark floor, its filled end caps facing the camera as steel pole faces, iron filings arcing between them.">
+      <img src="../assets/curve-bevel-arc-hero.webp" alt="A red horseshoe magnet made of one beveled Bezier curve on a dark floor, its filled end caps facing the camera as steel pole faces, iron filings arcing between them." 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> Curve tubes are curve datablocks: eight Bezier points, bevel_depth == 0.15, filled caps, and the evaluated mesh has deterministic topology (1044 verts, 1028 faces) resting on the floor.</div>
@@ -280,7 +280,7 @@ <h1>curve-bevel-arc</h1>
     <section class="detail-section md">
 <p>A runnable example that builds a beveled Bezier semicircle entirely through the curve data API — <code>splines.new(&#x27;BEZIER&#x27;)</code>, per-point <code>bezier_points</code>, <code>bevel_depth</code>, and <code>use_fill_caps</code> — so the curve renders as a solid tube without a prior mesh conversion.</p>
 <p><strong>What it witnesses:</strong> renderable curve tubes are curve datablocks, not meshes. The check asserts eight Bezier points, <code>bevel_depth == 0.15</code>, <code>use_fill_caps</code>, and that the depsgraph-evaluated mesh has the deterministic topology (1044 verts, 1028 faces for these resolution settings) with a Z span that rests on the floor (<code>[0, 2 × bevel]</code>) and an X span of <code>2 × radius + 2 × bevel</code>.</p>
-<p>Staging: both ends of the semicircle face −Y, so the still looks from −Y and shows both filled caps (<code>use_fill_caps</code>, the witness) face-on, with the arc sweeping behind them. The old angle showed one cap and the other end edge-on. The cap&#x27;s 12-sided outline is the pinned tessellation (<code>bevel_resolution</code> 4, locked by the 1044-vertex gate), not a presentation choice.</p>
+<p>Staging: the checked curve is presented as what a capped, beveled Bezier semicircle is in the world — a round-bar horseshoe magnet lying on the floor, open end to the camera. The two filled caps (<code>use_fill_caps</code>, the witness) are its ground-steel pole faces, turned face-on; an uncapped build would show two hollow pipe ends exactly there. The red enamel / bare-steel split is one material keyed on object-space Y, so the magnet stays a single curve datablock. The paper clips are beveled Bezier curves too (explicit <code>FREE</code> handles: straight legs plus quarter-circle bends), each lying along the field line that leaves its pole; the iron filings trace those lines — for two opposite line poles they are exact circular arcs through both pole faces. The cap&#x27;s 12-sided outline is the pinned tessellation (<code>bevel_resolution</code> 4, locked by the 1044-vertex gate), not a presentation choice. The render path rotates the object only; the check reads object-space evaluated geometry and runs before any staging.</p>
 <h2>Run</h2>
 <pre><code># Cheap correctness check (no render) — the CI check:
 blender --background --python curve_bevel_arc.py --
@@ -293,7 +293,7 @@ <h2>Run</h2>
 blender --background --python curve_bevel_arc.py -- --output arc.png --engine cycles</code></pre>
 <h2>Exit codes</h2>
 <p>Per-script sequential checks. <code>9</code> is a valid check code; there is no rule against it. <code>10</code> is also 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>Spline type is not BEZIER</td></tr><tr><td>4</td><td>Bezier point count ≠ 8</td></tr><tr><td>5</td><td><code>bevel_depth</code> ≠ 0.15</td></tr><tr><td>6</td><td><code>use_fill_caps</code> is False (<code>--no-caps</code> lands here)</td></tr><tr><td>7</td><td>Evaluated vert/face count off measured tessellation</td></tr><tr><td>8</td><td>Tube does not rest on the floor</td></tr><tr><td>9</td><td>Tube height ≠ 2 × bevel</td></tr><tr><td>10</td><td>X span off closed form; also gallery framing violation</td></tr><tr><td>11</td><td><code>--output</code> produced no file</td></tr></tbody></table></div>
+<div class="table-wrap"><table><thead><tr><th scope="col">Code</th><th scope="col">Meaning</th></tr></thead><tbody><tr><td>0</td><td>Success</td></tr><tr><td>1</td><td>Uncaught exception (FATAL wrapper)</td></tr><tr><td>2</td><td>argparse / usage</td></tr><tr><td>3</td><td>Spline type is not BEZIER</td></tr><tr><td>4</td><td>Bezier point count ≠ 8</td></tr><tr><td>5</td><td><code>bevel_depth</code> ≠ 0.15</td></tr><tr><td>6</td><td><code>use_fill_caps</code> is False (<code>--no-caps</code> lands here)</td></tr><tr><td>7</td><td>Evaluated vert/face count off measured tessellation</td></tr><tr><td>8</td><td>Tube does not rest on the floor</td></tr><tr><td>9</td><td>Tube height ≠ 2 × bevel</td></tr><tr><td>10</td><td>X span off closed form; also gallery framing violation</td></tr><tr><td>11</td><td><code>--output</code> produced no file; also asset-quality floor violation (<code>gallery_asset_quality</code>)</td></tr></tbody></table></div>
 <p>The <code>blender-smoke</code> workflow runs the check on Blender 5.2 LTS and 4.5 LTS (5.1 on the weekly cron, the <code>needs-5.1</code> PR label, or manual dispatch). Smoke does not pass <code>--output</code> or <code>--no-caps</code>.</p>
     </section>
     <section class="detail-section src">
@@ -316,6 +316,12 @@ <h2>Source</h2>
 ``--no-caps`` leaves ``use_fill_caps`` False and still asserts the ends are
 capped. That is the falsifier (``--same-axis`` in export-preset-axis).
 
+The still stages the checked curve as a round-bar horseshoe magnet: its two
+filled caps are the ground-steel pole faces, turned to the camera, with
+Bezier-wire paper clips (also beveled curves) and iron filings on the field
+lines between the poles. The object transform changes only for the render;
+the check reads object-space evaluated geometry and runs first.
+
 By default it runs only the correctness check (no render) — the CI smoke
 check. Pass --output to also render a still:
 
@@ -325,10 +331,12 @@ <h2>Source</h2>
 &quot;&quot;&quot;</span>
 <span class="k">import</span> bpy, bmesh, sys, os, math, argparse
 
-<span class="c"># Shared Layer 1 framing measurement (render path only) — see gallery_framing.py</span>
+<span class="c"># Shared Layer 1 framing and asset-quality measurement (render path only) —</span>
+<span class="c"># see gallery_framing.py and 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
 
 N_POINTS = <span class="n">8</span>
 RADIUS = <span class="n">1.5</span>
@@ -345,7 +353,7 @@ <h2>Source</h2>
 
 <span class="k">def</span> build(no_caps=<span class="k">False</span>):
     bpy.ops.wm.read_factory_settings(use_empty=<span class="k">True</span>)
-    curve = bpy.data.curves.new(<span class="s">&quot;Arc&quot;</span>, <span class="s">&#x27;CURVE&#x27;</span>)
+    curve = bpy.data.curves.new(<span class="s">&quot;Magnet&quot;</span>, <span class="s">&#x27;CURVE&#x27;</span>)
     curve.dimensions = <span class="s">&#x27;3D&#x27;</span>
     curve.bevel_depth = BEVEL
     curve.bevel_resolution = BEVEL_RES
@@ -362,7 +370,7 @@ <h2>Source</h2>
         bp.handle_left_type = <span class="s">&#x27;AUTO&#x27;</span>
         bp.handle_right_type = <span class="s">&#x27;AUTO&#x27;</span>
 
-    obj = bpy.data.objects.new(<span class="s">&quot;Arc&quot;</span>, curve)
+    obj = bpy.data.objects.new(<span class="s">&quot;Magnet&quot;</span>, curve)
     bpy.context.collection.objects.link(obj)
     <span class="k">return</span> obj
 
@@ -427,17 +435,282 @@ <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="c"># --- render-path presentation: a horseshoe magnet ------------------------</span>
+<span class="c"># The checked curve is staged as what a capped, beveled Bezier semicircle</span>
+<span class="c"># actually is in the world: a round-bar horseshoe magnet. The two filled</span>
+<span class="c"># caps (use_fill_caps, the witness) are the magnet&#x27;s ground pole faces, so</span>
+<span class="c"># they face the camera; an uncapped build would show two hollow pipe ends</span>
+<span class="c"># exactly where the steel faces are. The paper clips are beveled Bezier</span>
+<span class="c"># curves too (explicit FREE handles, straight legs + quarter-circle bends),</span>
+<span class="c"># so every tube in frame is authored on bpy.types.Curve, never meshed.</span>
+
+POLE_Y = <span class="n">0.42</span>          <span class="c"># object-space y below which the bar is bare pole steel</span>
+KAPPA = <span class="n">4.0</span> / <span class="n">3.0</span> * math.tan(math.pi / <span class="n">8.0</span>)  <span class="c"># quarter-circle Bezier handle factor</span>
+
+<span class="c"># Gem paper clip centerline, unit length along +X, tip (outer bend) at x=0.</span>
+<span class="c"># (&#x27;L&#x27;, end) is a straight leg; (&#x27;A&#x27;, center, radius, ccw) a 180-degree bend</span>
+<span class="c"># split into two quarter arcs (ccw=True turns left).</span>
+GEM_START = (<span class="n">0.60</span>, <span class="n">0.15</span>)
+GEM_PATH = (
+    (<span class="s">&#x27;L&#x27;</span>, (<span class="n">0.15</span>, <span class="n">0.15</span>)),
+    (<span class="s">&#x27;A&#x27;</span>, (<span class="n">0.15</span>, <span class="n">0.00</span>), <span class="n">0.15</span>, <span class="k">True</span>),
+    (<span class="s">&#x27;L&#x27;</span>, (<span class="n">0.85</span>, -<span class="n">0.15</span>)),
+    (<span class="s">&#x27;A&#x27;</span>, (<span class="n">0.85</span>, -<span class="n">0.04</span>), <span class="n">0.11</span>, <span class="k">True</span>),
+    (<span class="s">&#x27;L&#x27;</span>, (<span class="n">0.30</span>, <span class="n">0.07</span>)),
+    (<span class="s">&#x27;A&#x27;</span>, (<span class="n">0.30</span>, <span class="n">0.00</span>), <span class="n">0.07</span>, <span class="k">True</span>),
+    (<span class="s">&#x27;L&#x27;</span>, (<span class="n">0.72</span>, -<span class="n">0.07</span>)),
+)
+
+
+<span class="k">def</span> bezier_path_nodes(start, path, scale):
+    <span class="s">&quot;&quot;&quot;[(co, handle_left, handle_right)] for a line/arc path in the XY plane.
+
+    Lines get handles at thirds (exactly straight); each 180-degree bend is two
+    quarter arcs with the KAPPA handle length (circle to within 0.03 %).&quot;&quot;&quot;</span>
+    <span class="k">from</span> mathutils <span class="k">import</span> Vector
+    nodes = [[Vector((start[<span class="n">0</span>], start[<span class="n">1</span>], <span class="n">0.0</span>)) * scale, <span class="k">None</span>, <span class="k">None</span>]]
+    <span class="k">for</span> seg <span class="k">in</span> path:
+        p = nodes[-<span class="n">1</span>][<span class="n">0</span>]
+        <span class="k">if</span> seg[<span class="n">0</span>] == <span class="s">&#x27;L&#x27;</span>:
+            q = Vector((seg[<span class="n">1</span>][<span class="n">0</span>], seg[<span class="n">1</span>][<span class="n">1</span>], <span class="n">0.0</span>)) * scale
+            nodes[-<span class="n">1</span>][<span class="n">2</span>] = p + (q - p) / <span class="n">3.0</span>
+            nodes.append([q, q - (q - p) / <span class="n">3.0</span>, <span class="k">None</span>])
+            <span class="k">continue</span>
+        _, c, r, ccw = seg
+        c = Vector((c[<span class="n">0</span>], c[<span class="n">1</span>], <span class="n">0.0</span>)) * scale
+        r *= scale
+        a0 = math.atan2(p.y - c.y, p.x - c.x)
+        sgn = <span class="n">1.0</span> <span class="k">if</span> ccw <span class="k">else</span> -<span class="n">1.0</span>
+        <span class="k">for</span> k <span class="k">in</span> (<span class="n">1</span>, <span class="n">2</span>):
+            a_prev = a0 + sgn * (k - <span class="n">1</span>) * math.pi / <span class="n">2.0</span>
+            a_next = a0 + sgn * k * math.pi / <span class="n">2.0</span>
+            t_prev = Vector((-math.sin(a_prev), math.cos(a_prev), <span class="n">0.0</span>)) * sgn
+            t_next = Vector((-math.sin(a_next), math.cos(a_next), <span class="n">0.0</span>)) * sgn
+            q = c + Vector((math.cos(a_next), math.sin(a_next), <span class="n">0.0</span>)) * r
+            nodes[-<span class="n">1</span>][<span class="n">2</span>] = nodes[-<span class="n">1</span>][<span class="n">0</span>] + t_prev * KAPPA * r
+            nodes.append([q, q - t_next * KAPPA * r, <span class="k">None</span>])
+    <span class="c"># free end handles continue the end segments</span>
+    first, last = nodes[<span class="n">0</span>], nodes[-<span class="n">1</span>]
+    first[<span class="n">1</span>] = first[<span class="n">0</span>] - (first[<span class="n">2</span>] - first[<span class="n">0</span>])
+    last[<span class="n">2</span>] = last[<span class="n">0</span>] + (last[<span class="n">0</span>] - last[<span class="n">1</span>])
+    <span class="k">return</span> nodes
+
+
+<span class="k">def</span> make_wire(name, nodes, bevel, mat, parent, loc, rot_z):
+    cu = bpy.data.curves.new(name, <span class="s">&#x27;CURVE&#x27;</span>)
+    cu.dimensions = <span class="s">&#x27;3D&#x27;</span>
+    cu.bevel_depth = bevel
+    cu.bevel_resolution = <span class="n">3</span>
+    cu.resolution_u = <span class="n">10</span>
+    cu.use_fill_caps = <span class="k">True</span>
+    sp = cu.splines.new(<span class="s">&#x27;BEZIER&#x27;</span>)
+    sp.bezier_points.add(len(nodes) - <span class="n">1</span>)
+    <span class="k">for</span> bp, (co, hl, hr) <span class="k">in</span> zip(sp.bezier_points, nodes):
+        bp.handle_left_type = <span class="s">&#x27;FREE&#x27;</span>
+        bp.handle_right_type = <span class="s">&#x27;FREE&#x27;</span>
+        bp.co = co
+        bp.handle_left = hl
+        bp.handle_right = hr
+    cu.materials.append(mat)
+    ob = bpy.data.objects.new(name, cu)
+    bpy.context.scene.collection.objects.link(ob)
+    ob.parent = parent
+    ob.location = (loc[<span class="n">0</span>], loc[<span class="n">1</span>], bevel)  <span class="c"># wire rests on the floor</span>
+    ob.rotation_euler = (<span class="n">0.0</span>, <span class="n">0.0</span>, math.radians(rot_z))
+    <span class="k">return</span> ob
+
+
+<span class="k">def</span> principled(name, color, rough, metal=<span class="n">0.0</span>, spec=<span class="k">None</span>):
+    m = bpy.data.materials.new(name)
+    m.use_nodes = <span class="k">True</span>
+    b = m.node_tree.nodes[<span class="s">&quot;Principled BSDF&quot;</span>]
+    b.inputs[<span class="s">&quot;Base Color&quot;</span>].default_value = (*color, <span class="n">1.0</span>)
+    b.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = rough
+    b.inputs[<span class="s">&quot;Metallic&quot;</span>].default_value = metal
+    <span class="k">if</span> spec <span class="k">is</span> <span class="k">not</span> <span class="k">None</span>:
+        key = <span class="s">&quot;Specular IOR Level&quot;</span> <span class="k">if</span> <span class="s">&quot;Specular IOR Level&quot;</span> <span class="k">in</span> b.inputs <span class="k">else</span> <span class="s">&quot;Specular&quot;</span>
+        b.inputs[key].default_value = spec
+    <span class="k">return</span> m
+
+
+<span class="k">def</span> magnet_material():
+    <span class="s">&quot;&quot;&quot;Red enamel bar with ground-steel pole ends, split in object space.
+
+    The bar ends sit at object y=0 with the tube running along +y there, so
+    a y threshold cuts a clean band square to the bar near each pole.&quot;&quot;&quot;</span>
+    m = bpy.data.materials.new(<span class="s">&quot;MagnetEnamelAndPoles&quot;</span>)
+    m.use_nodes = <span class="k">True</span>
+    nt = m.node_tree
+    nodes, links = nt.nodes, nt.links
+    paint = nodes[<span class="s">&quot;Principled BSDF&quot;</span>]
+    paint.inputs[<span class="s">&quot;Base Color&quot;</span>].default_value = (<span class="n">0.72</span>, <span class="n">0.035</span>, <span class="n">0.03</span>, <span class="n">1.0</span>)
+    paint.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.3</span>
+    out = nodes[<span class="s">&quot;Material Output&quot;</span>]
+    steel = nodes.new(<span class="s">&quot;ShaderNodeBsdfPrincipled&quot;</span>)
+    steel.inputs[<span class="s">&quot;Base Color&quot;</span>].default_value = (<span class="n">0.82</span>, <span class="n">0.82</span>, <span class="n">0.85</span>, <span class="n">1.0</span>)
+    steel.inputs[<span class="s">&quot;Metallic&quot;</span>].default_value = <span class="n">0.7</span>
+    steel.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.32</span>
+    groove = nodes.new(<span class="s">&quot;ShaderNodeBsdfPrincipled&quot;</span>)
+    groove.inputs[<span class="s">&quot;Base Color&quot;</span>].default_value = (<span class="n">0.02</span>, <span class="n">0.02</span>, <span class="n">0.022</span>, <span class="n">1.0</span>)
+    groove.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.6</span>
+    tc = nodes.new(<span class="s">&quot;ShaderNodeTexCoord&quot;</span>)
+    sep = nodes.new(<span class="s">&quot;ShaderNodeSeparateXYZ&quot;</span>)
+    links.new(tc.outputs[<span class="s">&quot;Object&quot;</span>], sep.inputs[<span class="n">0</span>])
+    is_pole = nodes.new(<span class="s">&quot;ShaderNodeMath&quot;</span>)
+    is_pole.operation = <span class="s">&#x27;LESS_THAN&#x27;</span>
+    is_pole.inputs[<span class="n">1</span>].default_value = POLE_Y
+    links.new(sep.outputs[<span class="s">&quot;Y&quot;</span>], is_pole.inputs[<span class="n">0</span>])
+    in_groove = nodes.new(<span class="s">&quot;ShaderNodeMath&quot;</span>)
+    in_groove.operation = <span class="s">&#x27;COMPARE&#x27;</span>
+    in_groove.inputs[<span class="n">1</span>].default_value = POLE_Y + <span class="n">0.012</span>
+    in_groove.inputs[<span class="n">2</span>].default_value = <span class="n">0.012</span>
+    links.new(sep.outputs[<span class="s">&quot;Y&quot;</span>], in_groove.inputs[<span class="n">0</span>])
+    mix1 = nodes.new(<span class="s">&quot;ShaderNodeMixShader&quot;</span>)
+    links.new(is_pole.outputs[<span class="n">0</span>], mix1.inputs[<span class="n">0</span>])
+    links.new(paint.outputs[<span class="n">0</span>], mix1.inputs[<span class="n">1</span>])
+    links.new(steel.outputs[<span class="n">0</span>], mix1.inputs[<span class="n">2</span>])
+    mix2 = nodes.new(<span class="s">&quot;ShaderNodeMixShader&quot;</span>)
+    links.new(in_groove.outputs[<span class="n">0</span>], mix2.inputs[<span class="n">0</span>])
+    links.new(mix1.outputs[<span class="n">0</span>], mix2.inputs[<span class="n">1</span>])
+    links.new(groove.outputs[<span class="n">0</span>], mix2.inputs[<span class="n">2</span>])
+    links.new(mix2.outputs[<span class="n">0</span>], out.inputs[<span class="s">&quot;Surface&quot;</span>])
+    <span class="k">return</span> m
+
+
+<span class="k">def</span> make_bearings(parent, mat):
+    <span class="s">&quot;&quot;&quot;Steel balls pulled onto the right pole face (object-space placement).&quot;&quot;&quot;</span>
+    me = bpy.data.meshes.new(<span class="s">&quot;PoleBearings&quot;</span>)
+    r = <span class="n">0.075</span>
+    centers = [
+        (<span class="n">1.66</span>, -r, r),                           <span class="c"># on the face&#x27;s outer rim</span>
+        (<span class="n">1.70</span>, -r - <span class="n">0.148</span>, r),                   <span class="c"># chained off the first</span>
+        (<span class="n">1.60</span>, -r - <span class="n">0.22</span>, r * <span class="n">0.8</span>),              <span class="c"># a smaller one pulled in</span>
+    ]
+    bm = bmesh.new()
+    <span class="k">try</span>:
+        <span class="k">for</span> c <span class="k">in</span> centers:
+            geom = bmesh.ops.create_uvsphere(bm, u_segments=<span class="n">24</span>, v_segments=<span class="n">12</span>, radius=r)
+            bmesh.ops.translate(bm, verts=geom[<span class="s">&quot;verts&quot;</span>], vec=c)
+        <span class="k">for</span> f <span class="k">in</span> bm.faces:
+            f.smooth = <span class="k">True</span>
+        bm.to_mesh(me)
+    <span class="k">finally</span>:
+        bm.free()
+    me.materials.append(mat)
+    ob = bpy.data.objects.new(<span class="s">&quot;PoleBearings&quot;</span>, me)
+    bpy.context.scene.collection.objects.link(ob)
+    ob.parent = parent
+    <span class="k">return</span> ob
+
+
+<span class="c"># Field-line circle centres (object y). The field of two opposite parallel</span>
+<span class="c"># line poles is exact circles through both poles, centre on the bisector,</span>
+<span class="c"># so each filing line is a circular arc from pole face to pole face.</span>
+FIELD_CENTRES = (<span class="n">5.0</span>, <span class="n">3.2</span>, <span class="n">2.2</span>, <span class="n">1.55</span>, <span class="n">1.1</span>, <span class="n">0.75</span>, <span class="n">0.45</span>, <span class="n">0.2</span>)
+
+
+<span class="k">def</span> field_lines(half=<span class="n">1.5</span>):
+    <span class="s">&quot;&quot;&quot;Arcs (object XY, y &lt; 0) from the left pole face to the right one.&quot;&quot;&quot;</span>
+    <span class="k">from</span> mathutils <span class="k">import</span> Vector
+    lines = []
+    <span class="k">for</span> c <span class="k">in</span> FIELD_CENTRES:
+        r = math.hypot(half, c)
+        a0 = math.atan2(-c, -half)            <span class="c"># angle of the left pole seen from the centre</span>
+        a1 = math.atan2(-c, half)              <span class="c"># right pole ...</span>
+        <span class="k">if</span> a1 &lt; a0:                            <span class="c"># ... reached the low way round</span>
+            a1 += <span class="n">2</span> * math.pi
+        n = max(<span class="n">8</span>, int(abs(a1 - a0) * r / <span class="n">0.02</span>))
+        pts = []
+        <span class="k">for</span> k <span class="k">in</span> range(n + <span class="n">1</span>):
+            a = a0 + (a1 - a0) * k / n
+            p = Vector((r * math.cos(a), c + r * math.sin(a)))
+            <span class="k">if</span> p.y &lt; -<span class="n">0.02</span>:
+                pts.append(p)
+        lines.append(pts)
+    <span class="k">return</span> lines
+
+
+<span class="k">def</span> _seg_dist(p, a, b):
+    ab = b - a
+    t = max(<span class="n">0.0</span>, min(<span class="n">1.0</span>, (p - a).dot(ab) / max(ab.length_squared, <span class="n">1e-12</span>)))
+    <span class="k">return</span> (a + ab * t - p).length
+
+
+<span class="k">def</span> make_filings(parent, mat, avoid=(), seed=<span class="n">7</span>):
+    <span class="s">&quot;&quot;&quot;Iron filings strewn along the field lines: small tilted steel slivers
+    in one mesh, jittered off each arc and skipped under the clips. Scene
+    dressing, not the asset: its boxes would read as the asset&#x27;s right-angle
+    edges in gallery_asset_quality.&quot;&quot;&quot;</span>
+    <span class="k">import</span> random
+    <span class="k">from</span> mathutils <span class="k">import</span> Matrix, Vector
+    rnd = random.Random(seed)
+    me = bpy.data.meshes.new(<span class="s">&quot;IronFilings&quot;</span>)
+    bm = bmesh.new()
+    <span class="k">try</span>:
+        <span class="k">for</span> pts <span class="k">in</span> field_lines():
+            acc = <span class="n">0.0</span>
+            <span class="k">for</span> a, b <span class="k">in</span> zip(pts, pts[<span class="n">1</span>:]):
+                acc += (b - a).length
+                <span class="k">if</span> acc &lt; <span class="n">0.045</span>:
+                    <span class="k">continue</span>
+                acc = <span class="n">0.0</span>
+                d = (b - a).normalized()
+                nrm = Vector((-d.y, d.x))
+                c = a + nrm * rnd.uniform(-<span class="n">0.03</span>, <span class="n">0.03</span>) + d * rnd.uniform(-<span class="n">0.02</span>, <span class="n">0.02</span>)
+                <span class="k">if</span> any(_seg_dist(c, s0, s1) &lt; <span class="n">0.07</span> <span class="k">for</span> s0, s1 <span class="k">in</span> avoid):
+                    <span class="k">continue</span>
+                ln = rnd.uniform(<span class="n">0.045</span>, <span class="n">0.08</span>)
+                geom = bmesh.ops.create_cube(bm, size=<span class="n">1.0</span>)
+                vs = geom[<span class="s">&quot;verts&quot;</span>]
+                bmesh.ops.scale(bm, verts=vs, vec=(ln, <span class="n">0.014</span>, <span class="n">0.009</span>))
+                yaw = math.atan2(d.y, d.x) + rnd.uniform(-<span class="n">0.22</span>, <span class="n">0.22</span>)
+                rot = Matrix.Rotation(yaw, <span class="n">4</span>, <span class="s">&#x27;Z&#x27;</span>) @ Matrix.Rotation(rnd.uniform(-<span class="n">0.6</span>, <span class="n">0.6</span>), <span class="n">4</span>, <span class="s">&#x27;X&#x27;</span>)
+                bmesh.ops.transform(bm, verts=vs, matrix=rot)
+                bmesh.ops.translate(bm, verts=vs, vec=(c.x, c.y, <span class="n">0.006</span>))
+        bm.to_mesh(me)
+    <span class="k">finally</span>:
+        bm.free()
+    me.materials.append(mat)
+    ob = bpy.data.objects.new(<span class="s">&quot;IronFilings&quot;</span>, me)
+    bpy.context.scene.collection.objects.link(ob)
+    ob.parent = parent
+    <span class="k">return</span> ob
+
+
+<span class="k">def</span> clip_segments(nodes, loc, rot_z):
+    <span class="s">&quot;&quot;&quot;The clip&#x27;s node polyline in the magnet&#x27;s object XY (for filings).&quot;&quot;&quot;</span>
+    <span class="k">from</span> mathutils <span class="k">import</span> Matrix, Vector
+    m = Matrix.Rotation(math.radians(rot_z), <span class="n">2</span>)
+    pts = [m @ Vector((co.x, co.y)) + Vector(loc) <span class="k">for</span> co, _, _ <span class="k">in</span> nodes]
+    <span class="k">return</span> list(zip(pts, pts[<span class="n">1</span>:]))
+
+
 <span class="k">def</span> render_still(obj, path, engine):
     scene = bpy.context.scene
-    mat = bpy.data.materials.new(<span class="s">&quot;Rose&quot;</span>)
-    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 = (<span class="n">0.95</span>, <span class="n">0.10</span>, <span class="n">0.38</span>, <span class="n">1.0</span>)  <span class="c"># rose</span>
-    bsdf.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.24</span>
-    obj.data.materials.append(mat)
-    <span class="c"># both capped ends face -Y with the arc unrotated, so the camera on -Y</span>
-    <span class="c"># sees the two caps (the witness) face-on and the arc sweeping behind</span>
+    obj.data.materials.append(magnet_material())
+    <span class="c"># the open end (both capped pole faces) points at the camera on -Y</span>
     obj.rotation_euler = (<span class="n">0.0</span>, <span class="n">0.0</span>, math.radians(-<span class="n">8</span>))
+    bpy.context.view_layer.update()
+
+    teal = principled(<span class="s">&quot;ClipVinylTeal&quot;</span>, (<span class="n">0.0</span>, <span class="n">0.34</span>, <span class="n">0.40</span>), <span class="n">0.35</span>)
+    amber = principled(<span class="s">&quot;ClipVinylAmber&quot;</span>, (<span class="n">0.95</span>, <span class="n">0.52</span>, <span class="n">0.02</span>), <span class="n">0.35</span>)
+    chrome = principled(<span class="s">&quot;BearingChrome&quot;</span>, (<span class="n">0.9</span>, <span class="n">0.9</span>, <span class="n">0.92</span>), <span class="n">0.18</span>, metal=<span class="n">0.85</span>)
+
+    clip_len = <span class="n">0.85</span>
+    gem = bezier_path_nodes(GEM_START, GEM_PATH, clip_len)
+    bevel_w = <span class="n">0.02</span>
+    <span class="c"># each clip&#x27;s tip touches a pole face (object y=0) at the floor and the</span>
+    <span class="c"># clip lies along the field line leaving that pole, as a real one would</span>
+    placements = ((<span class="s">&quot;ClipTeal&quot;</span>, teal, (-<span class="n">1.5</span>, -bevel_w), -<span class="n">46.0</span>),
+                  (<span class="s">&quot;ClipAmber&quot;</span>, amber, (<span class="n">1.5</span>, -bevel_w), -<span class="n">134.0</span>))
+    clips, avoid = [], []
+    <span class="k">for</span> name, mat, loc, ang <span class="k">in</span> placements:
+        clips.append(make_wire(name, gem, bevel_w, mat, obj, loc, ang))
+        avoid += clip_segments(gem, loc, ang)
+    bearings = make_bearings(obj, chrome)
+    make_filings(obj, principled(<span class="s">&quot;FilingSteel&quot;</span>, (<span class="n">0.55</span>, <span class="n">0.56</span>, <span class="n">0.6</span>), <span class="n">0.3</span>, metal=<span class="n">0.9</span>),
+                 avoid=avoid)
+    parts = [obj, *clips, bearings]
 
     floor_me = bpy.data.meshes.new(<span class="s">&quot;Floor&quot;</span>)
     bm = bmesh.new()
@@ -446,16 +719,12 @@ <h2>Source</h2>
         bm.to_mesh(floor_me)
     <span class="k">finally</span>:
         bm.free()
-    fmat = bpy.data.materials.new(<span class="s">&quot;Studio&quot;</span>)
-    fmat.use_nodes = <span class="k">True</span>
-    fb = fmat.node_tree.nodes[<span class="s">&quot;Principled BSDF&quot;</span>]
-    fb.inputs[<span class="s">&quot;Base Color&quot;</span>].default_value = (<span class="n">0.03</span>, <span class="n">0.032</span>, <span class="n">0.037</span>, <span class="n">1.0</span>)
-    fb.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.7</span>
+    fmat = 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">0.7</span>)
     floor_me.materials.append(fmat)
     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">7.0</span>, <span class="n">0.0</span>)
     wall.rotation_euler = (math.radians(<span class="n">90</span>), <span class="n">0.0</span>, <span class="n">0.0</span>)
     scene.collection.objects.link(wall)
 
@@ -465,7 +734,7 @@ <h2>Source</h2>
     scene.world = world
 
     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.55</span>, BEVEL)
+    aim.location = (<span class="n">0.0</span>, -<span class="n">0.3</span>, <span class="n">0.1</span>)
     scene.collection.objects.link(aim)
 
     <span class="k">def</span> light(name, loc, energy, size, col):
@@ -481,23 +750,32 @@ <h2>Source</h2>
         lc.track_axis = <span class="s">&#x27;TRACK_NEGATIVE_Z&#x27;</span>
         lc.up_axis = <span class="s">&#x27;UP_Y&#x27;</span>
 
-    <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">3.5</span>, -<span class="n">4.5</span>, <span class="n">5.5</span>), <span class="n">550.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>))
-    light(<span class="s">&quot;Fill&quot;</span>, (<span class="n">5.0</span>, -<span class="n">3.5</span>, <span class="n">2.5</span>), <span class="n">110.0</span>, <span class="n">8.0</span>, (<span class="n">0.75</span>, <span class="n">0.85</span>, <span class="n">1.0</span>))
+    light(<span class="s">&quot;Key&quot;</span>, (-<span class="n">3.5</span>, -<span class="n">3.0</span>, <span class="n">6.5</span>), <span class="n">330.0</span>, <span class="n">4.0</span>, (<span class="n">1.0</span>, <span class="n">0.96</span>, <span class="n">0.9</span>))
+    light(<span class="s">&quot;Fill&quot;</span>, (<span class="n">5.0</span>, -<span class="n">3.5</span>, <span class="n">2.5</span>), <span class="n">70.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>))
+    light(<span class="s">&quot;Rim&quot;</span>, (<span class="n">0.5</span>, <span class="n">4.2</span>, <span class="n">4.5</span>), <span class="n">160.0</span>, <span class="n">3.0</span>, (<span class="n">0.6</span>, <span class="n">0.78</span>, <span class="n">1.0</span>))
+    <span class="c"># the wedge sits between the magnet and the wall and aims at the wall,</span>
+    <span class="c"># so its pool lands on the backdrop, not across the floor</span>
+    wall_spot = bpy.data.objects.new(<span class="s">&quot;WedgeTarget&quot;</span>, <span class="k">None</span>)
+    wall_spot.location = (<span class="n">1.2</span>, <span class="n">7.0</span>, <span class="n">1.4</span>)
+    scene.collection.objects.link(wall_spot)
     wedge = bpy.data.lights.new(<span class="s">&quot;Wedge&quot;</span>, <span class="s">&#x27;AREA&#x27;</span>)
-    wedge.energy = <span class="n">380.0</span>
-    wedge.size = <span class="n">6.0</span>
+    wedge.energy = <span class="n">300.0</span>
+    wedge.size = <span class="n">5.0</span>
     wedge.color = (<span class="n">1.0</span>, <span class="n">0.76</span>, <span class="n">0.5</span>)
     wob = bpy.data.objects.new(<span class="s">&quot;Wedge&quot;</span>, wedge)
-    wob.location = (<span class="n">2.5</span>, <span class="n">5.5</span>, <span class="n">4.0</span>)
-    wob.rotation_euler = (math.radians(-<span class="n">68</span>), <span class="n">0.0</span>, math.radians(<span class="n">190</span>))
+    wob.location = (-<span class="n">0.5</span>, <span class="n">4.5</span>, <span class="n">3.4</span>)
     scene.collection.objects.link(wob)
+    wc = wob.constraints.new(<span class="s">&#x27;TRACK_TO&#x27;</span>)
+    wc.target = wall_spot
+    wc.track_axis = <span class="s">&#x27;TRACK_NEGATIVE_Z&#x27;</span>
+    wc.up_axis = <span class="s">&#x27;UP_Y&#x27;</span>
 
     cam_data = bpy.data.cameras.new(<span class="s">&quot;Cam&quot;</span>)
     cam_data.lens = <span class="n">50.0</span>
     cam = bpy.data.objects.new(<span class="s">&quot;Cam&quot;</span>, cam_data)
-    cam.location = (<span class="n">1.1</span>, -<span class="n">4.3</span>, <span class="n">2.55</span>)
+    cam.location = (<span class="n">0.55</span>, -<span class="n">4.9</span>, <span class="n">3.3</span>)
     scene.collection.objects.link(cam)
     scene.camera = cam
     track = cam.constraints.new(<span class="s">&#x27;TRACK_TO&#x27;</span>)
@@ -517,18 +795,23 @@ <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 rose tube toward salmon (docs/VISUAL-STYLE.md)</span>
+    <span class="c"># AgX would wash the red enamel toward salmon (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>
+    <span class="c"># Layer 1 gates, before the beauty render so a defective composition</span>
+    <span class="c"># ships no artifact: framing (silhouette matte, exit 10) on the magnet,</span>
+    <span class="c"># margins on everything that matters; asset quality (exit 11).</span>
     fcode = gallery_framing.check_framing(
         scene, cam,
         hero=[obj],
-        elements=[obj],
+        elements=parts,
         stage=[floor, wall],
     )
     <span class="k">if</span> fcode:
         <span class="k">return</span> fcode
+    qcode = gallery_asset_quality.check_asset_quality(
+        scene, cam, hero=parts, 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)
@@ -572,7 +855,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/curve-bevel-arc-hero.webp" alt="A magenta beveled curve tube lying in a semicircle on a dark floor, both filled end caps facing the camera." />
+    <img src="../assets/curve-bevel-arc-hero.webp" alt="A red horseshoe magnet made of one beveled Bezier curve on a dark floor, its filled end caps facing the camera as steel pole faces, iron filings arcing between them." />
   </dialog>
   <footer>
     <div class="statusbar">
diff --git a/docs/gallery/index.html b/docs/gallery/index.html
index 69c05a3f..3ce43a6b 100644
--- a/docs/gallery/index.html
+++ b/docs/gallery/index.html
@@ -475,7 +475,7 @@ <h2><a href="shape-key-blend/">shape-key-blend</a></h2>
       </article>
       <article class="card" data-tags="curves bevel">
         <a class="card-media" href="curve-bevel-arc/" tabindex="-1" aria-hidden="true">
-          <img src="assets/curve-bevel-arc-hero.webp" alt="A magenta beveled curve tube lying in a semicircle on a dark floor, both filled end caps facing the camera." loading="lazy" decoding="async" />
+          <img src="assets/curve-bevel-arc-hero.webp" alt="A red horseshoe magnet made of one beveled Bezier curve on a dark floor, its filled end caps facing the camera as steel pole faces, iron filings arcing between them." loading="lazy" decoding="async" />
         </a>
         <div class="card-body">
           <h2><a href="curve-bevel-arc/">curve-bevel-arc</a></h2>
diff --git a/examples/curve-bevel-arc/README.md b/examples/curve-bevel-arc/README.md
index 1153146b..1f118252 100644
--- a/examples/curve-bevel-arc/README.md
+++ b/examples/curve-bevel-arc/README.md
@@ -11,11 +11,20 @@ and that the depsgraph-evaluated mesh has the deterministic topology (1044 verts
 1028 faces for these resolution settings) with a Z span that rests on the floor
 (`[0, 2 × bevel]`) and an X span of `2 × radius + 2 × bevel`.
 
-Staging: both ends of the semicircle face −Y, so the still looks from −Y and
-shows both filled caps (`use_fill_caps`, the witness) face-on, with the arc
-sweeping behind them. The old angle showed one cap and the other end edge-on.
-The cap's 12-sided outline is the pinned tessellation (`bevel_resolution` 4,
-locked by the 1044-vertex gate), not a presentation choice.
+Staging: the checked curve is presented as what a capped, beveled Bezier
+semicircle is in the world — a round-bar horseshoe magnet lying on the floor,
+open end to the camera. The two filled caps (`use_fill_caps`, the witness) are
+its ground-steel pole faces, turned face-on; an uncapped build would show two
+hollow pipe ends exactly there. The red enamel / bare-steel split is one
+material keyed on object-space Y, so the magnet stays a single curve
+datablock. The paper clips are beveled Bezier curves too (explicit `FREE`
+handles: straight legs plus quarter-circle bends), each lying along the field
+line that leaves its pole; the iron filings trace those lines — for two
+opposite line poles they are exact circular arcs through both pole faces. The
+cap's 12-sided outline is the pinned tessellation (`bevel_resolution` 4,
+locked by the 1044-vertex gate), not a presentation choice. The render path
+rotates the object only; the check reads object-space evaluated geometry and
+runs before any staging.
 
 ## Run
 
@@ -49,7 +58,7 @@ against it. `10` is also the shared framing helper.
 | 8 | Tube does not rest on the floor |
 | 9 | Tube height ≠ 2 × bevel |
 | 10 | X span off closed form; also gallery framing violation |
-| 11 | `--output` produced no file |
+| 11 | `--output` produced no file; also asset-quality floor violation (`gallery_asset_quality`) |
 
 The `blender-smoke` workflow runs the check on Blender 5.2 LTS and 4.5 LTS
 (5.1 on the weekly cron, the `needs-5.1` PR label, or manual dispatch).
diff --git a/examples/curve-bevel-arc/curve_bevel_arc.py b/examples/curve-bevel-arc/curve_bevel_arc.py
index bb0adafa..3ceeeb2f 100644
--- a/examples/curve-bevel-arc/curve_bevel_arc.py
+++ b/examples/curve-bevel-arc/curve_bevel_arc.py
@@ -12,6 +12,12 @@
 ``--no-caps`` leaves ``use_fill_caps`` False and still asserts the ends are
 capped. That is the falsifier (``--same-axis`` in export-preset-axis).
 
+The still stages the checked curve as a round-bar horseshoe magnet: its two
+filled caps are the ground-steel pole faces, turned to the camera, with
+Bezier-wire paper clips (also beveled curves) and iron filings on the field
+lines between the poles. The object transform changes only for the render;
+the check reads object-space evaluated geometry and runs first.
+
 By default it runs only the correctness check (no render) — the CI smoke
 check. Pass --output to also render a still:
 
@@ -21,10 +27,12 @@
 """
 import bpy, bmesh, sys, os, math, argparse
 
-# Shared Layer 1 framing measurement (render path only) — see gallery_framing.py
+# Shared Layer 1 framing and asset-quality measurement (render path only) —
+# see gallery_framing.py and 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
 
 N_POINTS = 8
 RADIUS = 1.5
@@ -41,7 +49,7 @@
 
 def build(no_caps=False):
     bpy.ops.wm.read_factory_settings(use_empty=True)
-    curve = bpy.data.curves.new("Arc", 'CURVE')
+    curve = bpy.data.curves.new("Magnet", 'CURVE')
     curve.dimensions = '3D'
     curve.bevel_depth = BEVEL
     curve.bevel_resolution = BEVEL_RES
@@ -58,7 +66,7 @@ def build(no_caps=False):
         bp.handle_left_type = 'AUTO'
         bp.handle_right_type = 'AUTO'
 
-    obj = bpy.data.objects.new("Arc", curve)
+    obj = bpy.data.objects.new("Magnet", curve)
     bpy.context.collection.objects.link(obj)
     return obj
 
@@ -123,17 +131,282 @@ def eevee_engine_id():
     return 'BLENDER_EEVEE' if bpy.app.version >= (5, 0, 0) else 'BLENDER_EEVEE_NEXT'
 
 
+# --- render-path presentation: a horseshoe magnet ------------------------
+# The checked curve is staged as what a capped, beveled Bezier semicircle
+# actually is in the world: a round-bar horseshoe magnet. The two filled
+# caps (use_fill_caps, the witness) are the magnet's ground pole faces, so
+# they face the camera; an uncapped build would show two hollow pipe ends
+# exactly where the steel faces are. The paper clips are beveled Bezier
+# curves too (explicit FREE handles, straight legs + quarter-circle bends),
+# so every tube in frame is authored on bpy.types.Curve, never meshed.
+
+POLE_Y = 0.42          # object-space y below which the bar is bare pole steel
+KAPPA = 4.0 / 3.0 * math.tan(math.pi / 8.0)  # quarter-circle Bezier handle factor
+
+# Gem paper clip centerline, unit length along +X, tip (outer bend) at x=0.
+# ('L', end) is a straight leg; ('A', center, radius, ccw) a 180-degree bend
+# split into two quarter arcs (ccw=True turns left).
+GEM_START = (0.60, 0.15)
+GEM_PATH = (
+    ('L', (0.15, 0.15)),
+    ('A', (0.15, 0.00), 0.15, True),
+    ('L', (0.85, -0.15)),
+    ('A', (0.85, -0.04), 0.11, True),
+    ('L', (0.30, 0.07)),
+    ('A', (0.30, 0.00), 0.07, True),
+    ('L', (0.72, -0.07)),
+)
+
+
+def bezier_path_nodes(start, path, scale):
+    """[(co, handle_left, handle_right)] for a line/arc path in the XY plane.
+
+    Lines get handles at thirds (exactly straight); each 180-degree bend is two
+    quarter arcs with the KAPPA handle length (circle to within 0.03 %)."""
+    from mathutils import Vector
+    nodes = [[Vector((start[0], start[1], 0.0)) * scale, None, None]]
+    for seg in path:
+        p = nodes[-1][0]
+        if seg[0] == 'L':
+            q = Vector((seg[1][0], seg[1][1], 0.0)) * scale
+            nodes[-1][2] = p + (q - p) / 3.0
+            nodes.append([q, q - (q - p) / 3.0, None])
+            continue
+        _, c, r, ccw = seg
+        c = Vector((c[0], c[1], 0.0)) * scale
+        r *= scale
+        a0 = math.atan2(p.y - c.y, p.x - c.x)
+        sgn = 1.0 if ccw else -1.0
+        for k in (1, 2):
+            a_prev = a0 + sgn * (k - 1) * math.pi / 2.0
+            a_next = a0 + sgn * k * math.pi / 2.0
+            t_prev = Vector((-math.sin(a_prev), math.cos(a_prev), 0.0)) * sgn
+            t_next = Vector((-math.sin(a_next), math.cos(a_next), 0.0)) * sgn
+            q = c + Vector((math.cos(a_next), math.sin(a_next), 0.0)) * r
+            nodes[-1][2] = nodes[-1][0] + t_prev * KAPPA * r
+            nodes.append([q, q - t_next * KAPPA * r, None])
+    # free end handles continue the end segments
+    first, last = nodes[0], nodes[-1]
+    first[1] = first[0] - (first[2] - first[0])
+    last[2] = last[0] + (last[0] - last[1])
+    return nodes
+
+
+def make_wire(name, nodes, bevel, mat, parent, loc, rot_z):
+    cu = bpy.data.curves.new(name, 'CURVE')
+    cu.dimensions = '3D'
+    cu.bevel_depth = bevel
+    cu.bevel_resolution = 3
+    cu.resolution_u = 10
+    cu.use_fill_caps = True
+    sp = cu.splines.new('BEZIER')
+    sp.bezier_points.add(len(nodes) - 1)
+    for bp, (co, hl, hr) in zip(sp.bezier_points, nodes):
+        bp.handle_left_type = 'FREE'
+        bp.handle_right_type = 'FREE'
+        bp.co = co
+        bp.handle_left = hl
+        bp.handle_right = hr
+    cu.materials.append(mat)
+    ob = bpy.data.objects.new(name, cu)
+    bpy.context.scene.collection.objects.link(ob)
+    ob.parent = parent
+    ob.location = (loc[0], loc[1], bevel)  # wire rests on the floor
+    ob.rotation_euler = (0.0, 0.0, math.radians(rot_z))
+    return ob
+
+
+def principled(name, color, rough, metal=0.0, spec=None):
+    m = bpy.data.materials.new(name)
+    m.use_nodes = True
+    b = m.node_tree.nodes["Principled BSDF"]
+    b.inputs["Base Color"].default_value = (*color, 1.0)
+    b.inputs["Roughness"].default_value = rough
+    b.inputs["Metallic"].default_value = metal
+    if spec is not None:
+        key = "Specular IOR Level" if "Specular IOR Level" in b.inputs else "Specular"
+        b.inputs[key].default_value = spec
+    return m
+
+
+def magnet_material():
+    """Red enamel bar with ground-steel pole ends, split in object space.
+
+    The bar ends sit at object y=0 with the tube running along +y there, so
+    a y threshold cuts a clean band square to the bar near each pole."""
+    m = bpy.data.materials.new("MagnetEnamelAndPoles")
+    m.use_nodes = True
+    nt = m.node_tree
+    nodes, links = nt.nodes, nt.links
+    paint = nodes["Principled BSDF"]
+    paint.inputs["Base Color"].default_value = (0.72, 0.035, 0.03, 1.0)
+    paint.inputs["Roughness"].default_value = 0.3
+    out = nodes["Material Output"]
+    steel = nodes.new("ShaderNodeBsdfPrincipled")
+    steel.inputs["Base Color"].default_value = (0.82, 0.82, 0.85, 1.0)
+    steel.inputs["Metallic"].default_value = 0.7
+    steel.inputs["Roughness"].default_value = 0.32
+    groove = nodes.new("ShaderNodeBsdfPrincipled")
+    groove.inputs["Base Color"].default_value = (0.02, 0.02, 0.022, 1.0)
+    groove.inputs["Roughness"].default_value = 0.6
+    tc = nodes.new("ShaderNodeTexCoord")
+    sep = nodes.new("ShaderNodeSeparateXYZ")
+    links.new(tc.outputs["Object"], sep.inputs[0])
+    is_pole = nodes.new("ShaderNodeMath")
+    is_pole.operation = 'LESS_THAN'
+    is_pole.inputs[1].default_value = POLE_Y
+    links.new(sep.outputs["Y"], is_pole.inputs[0])
+    in_groove = nodes.new("ShaderNodeMath")
+    in_groove.operation = 'COMPARE'
+    in_groove.inputs[1].default_value = POLE_Y + 0.012
+    in_groove.inputs[2].default_value = 0.012
+    links.new(sep.outputs["Y"], in_groove.inputs[0])
+    mix1 = nodes.new("ShaderNodeMixShader")
+    links.new(is_pole.outputs[0], mix1.inputs[0])
+    links.new(paint.outputs[0], mix1.inputs[1])
+    links.new(steel.outputs[0], mix1.inputs[2])
+    mix2 = nodes.new("ShaderNodeMixShader")
+    links.new(in_groove.outputs[0], mix2.inputs[0])
+    links.new(mix1.outputs[0], mix2.inputs[1])
+    links.new(groove.outputs[0], mix2.inputs[2])
+    links.new(mix2.outputs[0], out.inputs["Surface"])
+    return m
+
+
+def make_bearings(parent, mat):
+    """Steel balls pulled onto the right pole face (object-space placement)."""
+    me = bpy.data.meshes.new("PoleBearings")
+    r = 0.075
+    centers = [
+        (1.66, -r, r),                           # on the face's outer rim
+        (1.70, -r - 0.148, r),                   # chained off the first
+        (1.60, -r - 0.22, r * 0.8),              # a smaller one pulled in
+    ]
+    bm = bmesh.new()
+    try:
+        for c in centers:
+            geom = bmesh.ops.create_uvsphere(bm, u_segments=24, v_segments=12, radius=r)
+            bmesh.ops.translate(bm, verts=geom["verts"], vec=c)
+        for f in bm.faces:
+            f.smooth = True
+        bm.to_mesh(me)
+    finally:
+        bm.free()
+    me.materials.append(mat)
+    ob = bpy.data.objects.new("PoleBearings", me)
+    bpy.context.scene.collection.objects.link(ob)
+    ob.parent = parent
+    return ob
+
+
+# Field-line circle centres (object y). The field of two opposite parallel
+# line poles is exact circles through both poles, centre on the bisector,
+# so each filing line is a circular arc from pole face to pole face.
+FIELD_CENTRES = (5.0, 3.2, 2.2, 1.55, 1.1, 0.75, 0.45, 0.2)
+
+
+def field_lines(half=1.5):
+    """Arcs (object XY, y < 0) from the left pole face to the right one."""
+    from mathutils import Vector
+    lines = []
+    for c in FIELD_CENTRES:
+        r = math.hypot(half, c)
+        a0 = math.atan2(-c, -half)            # angle of the left pole seen from the centre
+        a1 = math.atan2(-c, half)              # right pole ...
+        if a1 < a0:                            # ... reached the low way round
+            a1 += 2 * math.pi
+        n = max(8, int(abs(a1 - a0) * r / 0.02))
+        pts = []
+        for k in range(n + 1):
+            a = a0 + (a1 - a0) * k / n
+            p = Vector((r * math.cos(a), c + r * math.sin(a)))
+            if p.y < -0.02:
+                pts.append(p)
+        lines.append(pts)
+    return lines
+
+
+def _seg_dist(p, a, b):
+    ab = b - a
+    t = max(0.0, min(1.0, (p - a).dot(ab) / max(ab.length_squared, 1e-12)))
+    return (a + ab * t - p).length
+
+
+def make_filings(parent, mat, avoid=(), seed=7):
+    """Iron filings strewn along the field lines: small tilted steel slivers
+    in one mesh, jittered off each arc and skipped under the clips. Scene
+    dressing, not the asset: its boxes would read as the asset's right-angle
+    edges in gallery_asset_quality."""
+    import random
+    from mathutils import Matrix, Vector
+    rnd = random.Random(seed)
+    me = bpy.data.meshes.new("IronFilings")
+    bm = bmesh.new()
+    try:
+        for pts in field_lines():
+            acc = 0.0
+            for a, b in zip(pts, pts[1:]):
+                acc += (b - a).length
+                if acc < 0.045:
+                    continue
+                acc = 0.0
+                d = (b - a).normalized()
+                nrm = Vector((-d.y, d.x))
+                c = a + nrm * rnd.uniform(-0.03, 0.03) + d * rnd.uniform(-0.02, 0.02)
+                if any(_seg_dist(c, s0, s1) < 0.07 for s0, s1 in avoid):
+                    continue
+                ln = rnd.uniform(0.045, 0.08)
+                geom = bmesh.ops.create_cube(bm, size=1.0)
+                vs = geom["verts"]
+                bmesh.ops.scale(bm, verts=vs, vec=(ln, 0.014, 0.009))
+                yaw = math.atan2(d.y, d.x) + rnd.uniform(-0.22, 0.22)
+                rot = Matrix.Rotation(yaw, 4, 'Z') @ Matrix.Rotation(rnd.uniform(-0.6, 0.6), 4, 'X')
+                bmesh.ops.transform(bm, verts=vs, matrix=rot)
+                bmesh.ops.translate(bm, verts=vs, vec=(c.x, c.y, 0.006))
+        bm.to_mesh(me)
+    finally:
+        bm.free()
+    me.materials.append(mat)
+    ob = bpy.data.objects.new("IronFilings", me)
+    bpy.context.scene.collection.objects.link(ob)
+    ob.parent = parent
+    return ob
+
+
+def clip_segments(nodes, loc, rot_z):
+    """The clip's node polyline in the magnet's object XY (for filings)."""
+    from mathutils import Matrix, Vector
+    m = Matrix.Rotation(math.radians(rot_z), 2)
+    pts = [m @ Vector((co.x, co.y)) + Vector(loc) for co, _, _ in nodes]
+    return list(zip(pts, pts[1:]))
+
+
 def render_still(obj, path, engine):
     scene = bpy.context.scene
-    mat = bpy.data.materials.new("Rose")
-    mat.use_nodes = True
-    bsdf = mat.node_tree.nodes["Principled BSDF"]
-    bsdf.inputs["Base Color"].default_value = (0.95, 0.10, 0.38, 1.0)  # rose
-    bsdf.inputs["Roughness"].default_value = 0.24
-    obj.data.materials.append(mat)
-    # both capped ends face -Y with the arc unrotated, so the camera on -Y
-    # sees the two caps (the witness) face-on and the arc sweeping behind
+    obj.data.materials.append(magnet_material())
+    # the open end (both capped pole faces) points at the camera on -Y
     obj.rotation_euler = (0.0, 0.0, math.radians(-8))
+    bpy.context.view_layer.update()
+
+    teal = principled("ClipVinylTeal", (0.0, 0.34, 0.40), 0.35)
+    amber = principled("ClipVinylAmber", (0.95, 0.52, 0.02), 0.35)
+    chrome = principled("BearingChrome", (0.9, 0.9, 0.92), 0.18, metal=0.85)
+
+    clip_len = 0.85
+    gem = bezier_path_nodes(GEM_START, GEM_PATH, clip_len)
+    bevel_w = 0.02
+    # each clip's tip touches a pole face (object y=0) at the floor and the
+    # clip lies along the field line leaving that pole, as a real one would
+    placements = (("ClipTeal", teal, (-1.5, -bevel_w), -46.0),
+                  ("ClipAmber", amber, (1.5, -bevel_w), -134.0))
+    clips, avoid = [], []
+    for name, mat, loc, ang in placements:
+        clips.append(make_wire(name, gem, bevel_w, mat, obj, loc, ang))
+        avoid += clip_segments(gem, loc, ang)
+    bearings = make_bearings(obj, chrome)
+    make_filings(obj, principled("FilingSteel", (0.55, 0.56, 0.6), 0.3, metal=0.9),
+                 avoid=avoid)
+    parts = [obj, *clips, bearings]
 
     floor_me = bpy.data.meshes.new("Floor")
     bm = bmesh.new()
@@ -142,16 +415,12 @@ def render_still(obj, path, engine):
         bm.to_mesh(floor_me)
     finally:
         bm.free()
-    fmat = bpy.data.materials.new("Studio")
-    fmat.use_nodes = True
-    fb = fmat.node_tree.nodes["Principled BSDF"]
-    fb.inputs["Base Color"].default_value = (0.03, 0.032, 0.037, 1.0)
-    fb.inputs["Roughness"].default_value = 0.7
+    fmat = principled("Studio", (0.03, 0.032, 0.037), 0.7)
     floor_me.materials.append(fmat)
     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, 7.0, 0.0)
     wall.rotation_euler = (math.radians(90), 0.0, 0.0)
     scene.collection.objects.link(wall)
 
@@ -161,7 +430,7 @@ def render_still(obj, path, engine):
     scene.world = world
 
     aim = bpy.data.objects.new("Aim", None)
-    aim.location = (0.0, 0.55, BEVEL)
+    aim.location = (0.0, -0.3, 0.1)
     scene.collection.objects.link(aim)
 
     def light(name, loc, energy, size, col):
@@ -177,23 +446,32 @@ def light(name, loc, energy, size, col):
         lc.track_axis = 'TRACK_NEGATIVE_Z'
         lc.up_axis = 'UP_Y'
 
-    # 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", (-3.5, -4.5, 5.5), 550.0, 4.5, (1.0, 0.96, 0.9))
-    light("Fill", (5.0, -3.5, 2.5), 110.0, 8.0, (0.75, 0.85, 1.0))
+    light("Key", (-3.5, -3.0, 6.5), 330.0, 4.0, (1.0, 0.96, 0.9))
+    light("Fill", (5.0, -3.5, 2.5), 70.0, 9.0, (0.75, 0.85, 1.0))
+    light("Rim", (0.5, 4.2, 4.5), 160.0, 3.0, (0.6, 0.78, 1.0))
+    # the wedge sits between the magnet and the wall and aims at the wall,
+    # so its pool lands on the backdrop, not across the floor
+    wall_spot = bpy.data.objects.new("WedgeTarget", None)
+    wall_spot.location = (1.2, 7.0, 1.4)
+    scene.collection.objects.link(wall_spot)
     wedge = bpy.data.lights.new("Wedge", 'AREA')
-    wedge.energy = 380.0
-    wedge.size = 6.0
+    wedge.energy = 300.0
+    wedge.size = 5.0
     wedge.color = (1.0, 0.76, 0.5)
     wob = bpy.data.objects.new("Wedge", wedge)
-    wob.location = (2.5, 5.5, 4.0)
-    wob.rotation_euler = (math.radians(-68), 0.0, math.radians(190))
+    wob.location = (-0.5, 4.5, 3.4)
     scene.collection.objects.link(wob)
+    wc = wob.constraints.new('TRACK_TO')
+    wc.target = wall_spot
+    wc.track_axis = 'TRACK_NEGATIVE_Z'
+    wc.up_axis = 'UP_Y'
 
     cam_data = bpy.data.cameras.new("Cam")
     cam_data.lens = 50.0
     cam = bpy.data.objects.new("Cam", cam_data)
-    cam.location = (1.1, -4.3, 2.55)
+    cam.location = (0.55, -4.9, 3.3)
     scene.collection.objects.link(cam)
     scene.camera = cam
     track = cam.constraints.new('TRACK_TO')
@@ -213,18 +491,23 @@ def light(name, loc, energy, size, col):
     scene.render.resolution_y = 720
     scene.render.image_settings.file_format = 'PNG'
     scene.render.filepath = path
-    # AgX would wash the rose tube toward salmon (docs/VISUAL-STYLE.md)
+    # AgX would wash the red enamel toward salmon (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.
+    # Layer 1 gates, before the beauty render so a defective composition
+    # ships no artifact: framing (silhouette matte, exit 10) on the magnet,
+    # margins on everything that matters; asset quality (exit 11).
     fcode = gallery_framing.check_framing(
         scene, cam,
         hero=[obj],
-        elements=[obj],
+        elements=parts,
         stage=[floor, wall],
     )
     if fcode:
         return fcode
+    qcode = gallery_asset_quality.check_asset_quality(
+        scene, cam, hero=parts, 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)
diff --git a/examples/curve-bevel-arc/preview.webp b/examples/curve-bevel-arc/preview.webp
index 431bfd59..dd2a5c32 100644
Binary files a/examples/curve-bevel-arc/preview.webp and b/examples/curve-bevel-arc/preview.webp differ
diff --git a/examples/gallery.json b/examples/gallery.json
index 3cceb6bd..f3f1ce8f 100644
--- a/examples/gallery.json
+++ b/examples/gallery.json
@@ -165,7 +165,7 @@
       "name": "curve-bevel-arc",
       "dir": "examples/curve-bevel-arc",
       "teaches": "A beveled Bezier semicircle authored on bpy.types.Curve — splines.new('BEZIER'), bezier_points, bevel_depth, use_fill_caps — so the curve renders as a solid tube without a prior mesh conversion.",
-      "alt": "A magenta beveled curve tube lying in a semicircle on a dark floor, both filled end caps facing the camera.",
+      "alt": "A red horseshoe magnet made of one beveled Bezier curve on a dark floor, its filled end caps facing the camera as steel pole faces, iron filings arcing between them.",
       "witnessesFix": "Curve tubes are curve datablocks: eight Bezier points, bevel_depth == 0.15, filled caps, and the evaluated mesh has deterministic topology (1044 verts, 1028 faces) resting on the floor.",
       "hero": "docs/gallery/assets/curve-bevel-arc-hero.webp",
       "preview": "examples/curve-bevel-arc/preview.webp",
diff --git a/examples/gallery_asset_quality.py b/examples/gallery_asset_quality.py
index d2881d57..b89a2ba9 100644
--- a/examples/gallery_asset_quality.py
+++ b/examples/gallery_asset_quality.py
@@ -12,7 +12,7 @@
 - **materials** — distinct materials across the hero's parts. A single
   flat Principled slot across an entire prop is the gallery's most
   reliable placeholder predictor.
-- **parts** — named mesh parts the hero is assembled from, excluding
+- **parts** — named mesh or curve parts the hero is assembled from, excluding
   default datablock names (Cube, Sphere, Plane, ...). Designed assets are
   assembled, not dumped.
 - **edge90** — fraction of manifold mesh edges whose dihedral angle is
@@ -80,17 +80,46 @@ def _as_list(objs):
 
 
 def _hero_meshes(hero):
+    """(name, data, object) per hero part. A part is a mesh object or a
+    curve object (a beveled Bezier tube is a renderable part authored on
+    bpy.types.Curve — curve-bevel-arc). Both datablocks carry `.materials`;
+    geometry is read through _part_mesh."""
     meshes = []
     for ob in hero:
-        if ob.type == "MESH" and ob.data is not None:
-            meshes.append((ob.name, ob.data))
+        if ob.type in ("MESH", "CURVE") and ob.data is not None:
+            meshes.append((ob.name, ob.data, ob))
     return meshes
 
 
+def _edge90_counts(me):
+    total = right = degenerate = 0
+    bm = bmesh.new()
+    try:
+        bm.from_mesh(me)
+        for e in bm.edges:
+            if len(e.link_faces) != 2:
+                continue
+            n1 = e.link_faces[0].normal
+            n2 = e.link_faces[1].normal
+            # A zero-area face has a zero-length normal, and Vector.angle
+            # RAISES on one. Reporting beats throwing: a degenerate face is
+            # a real defect the caller should hear about, not a crash that
+            # hides every other measurement on the asset.
+            if n1.length_squared <= 0.0 or n2.length_squared <= 0.0:
+                degenerate += 1
+                continue
+            total += 1
+            if abs(math.degrees(n1.angle(n2)) - 90.0) <= EDGE90_DEG:
+                right += 1
+    finally:
+        bm.free()
+    return total, right, degenerate
+
+
 def measure_parts(hero):
     """(part count, offending default-ish names)."""
     meshes = _hero_meshes(hero)
-    bad = [name for name, _ in meshes
+    bad = [name for name, _, _ in meshes
            if name.lower().split(".")[0] in DEFAULT_NAMES]
     return len(meshes), bad
 
@@ -103,7 +132,7 @@ def measure_materials(hero):
     from collections import Counter
     distinct = set()
     primary = Counter()
-    for _, me in _hero_meshes(hero):
+    for _, me, _ in _hero_meshes(hero):
         slots = [m for m in me.materials if m is not None]
         for slot in slots:
             distinct.add(slot.name)
@@ -118,31 +147,28 @@ def measure_edge90(hero):
 
     Boundary edges (open kit ends, sheet rims) are excluded — they have no
     dihedral to treat. Angles are face-normal angles on manifold edges.
+    A curve part is measured on its depsgraph-evaluated tessellation (the
+    tube the renderer draws), freed with to_mesh_clear().
     """
     total = 0
     right = 0
     degenerate = 0
-    for _, me in _hero_meshes(hero):
-        bm = bmesh.new()
-        try:
-            bm.from_mesh(me)
-            for e in bm.edges:
-                if len(e.link_faces) != 2:
-                    continue
-                n1 = e.link_faces[0].normal
-                n2 = e.link_faces[1].normal
-                # A zero-area face has a zero-length normal, and Vector.angle
-                # RAISES on one. Reporting beats throwing: a degenerate face is
-                # a real defect the caller should hear about, not a crash that
-                # hides every other measurement on the asset.
-                if n1.length_squared <= 0.0 or n2.length_squared <= 0.0:
-                    degenerate += 1
-                    continue
-                total += 1
-                if abs(math.degrees(n1.angle(n2)) - 90.0) <= EDGE90_DEG:
-                    right += 1
-        finally:
-            bm.free()
+    depsgraph = None
+    for _, data, ob in _hero_meshes(hero):
+        if ob.type == "MESH":
+            t, r, d = _edge90_counts(data)
+        else:
+            if depsgraph is None:
+                depsgraph = bpy.context.evaluated_depsgraph_get()
+            ev = ob.evaluated_get(depsgraph)
+            me = ev.to_mesh()
+            try:
+                t, r, d = _edge90_counts(me)
+            finally:
+                ev.to_mesh_clear()
+        total += t
+        right += r
+        degenerate += d
     return (right / total) if total else 0.0, right, total, degenerate
 
 
diff --git a/scripts/asset_sheet.py b/scripts/asset_sheet.py
index 7f9bd197..0608ee5b 100644
--- a/scripts/asset_sheet.py
+++ b/scripts/asset_sheet.py
@@ -13,7 +13,7 @@
 
 For each name the Blender side (``scripts/asset_sheet_panel.py``) stages the
 entry through the README's documented ``--output`` command, keeps only the
-mesh objects matched by ``SELECT`` below, and re-renders them on a grey
+mesh (or curve) objects matched by ``SELECT`` below, and re-renders them on a grey
 sweep. Before this file the panel renderer lived in uncommitted scratch
 scripts, so a sheet could not be reproduced (the same gap #200 closed for
 heroes).
@@ -75,6 +75,7 @@
     "mesh-hygiene-audit": (r"^Valve\.", None),
     "gn-modifier-inputs": (r"^SpiralStair\.H3$", None),
     "gltf-export-roundtrip": (r"^Crate\.Authored$", None),
+    "curve-bevel-arc": (r"^(Magnet|Clip\w+|PoleBearings)$", None),
     "shape-key-blend": (r"^Vase$", None),
 }
 
diff --git a/scripts/asset_sheet_panel.py b/scripts/asset_sheet_panel.py
index 937b8d58..90ad9c00 100644
--- a/scripts/asset_sheet_panel.py
+++ b/scripts/asset_sheet_panel.py
@@ -11,7 +11,7 @@
 so the argv after ``--`` stays exactly the example's documented flags:
 
     BDT_SHEET_SCRIPT  path to the example's .py
-    BDT_SHEET_SELECT  regex matched against mesh object names (the asset)
+    BDT_SHEET_SELECT  regex matched against mesh/curve object names (the asset)
     BDT_SHEET_EXCLUDE optional regex of names to drop from that match
     BDT_SHEET_OUT     panel PNG to write
 """
@@ -55,11 +55,11 @@ def _pre(scene, depsgraph=None):
 
 sc = bpy.data.scenes[captured[-1]] if captured else bpy.context.scene
 asset = [ob for ob in sc.objects
-         if ob.type == "MESH" and re.search(inc_re, ob.name)
+         if ob.type in ("MESH", "CURVE") and re.search(inc_re, ob.name)
          and not (exc_re and re.search(exc_re, ob.name))]
 print(f"sheet: asset objects {[ob.name for ob in asset]}")
 if not asset:
-    print(f"sheet: no mesh object matches {inc_re!r}", file=sys.stderr)
+    print(f"sheet: no mesh or curve object matches {inc_re!r}", file=sys.stderr)
     sys.exit(4)
 
 # The measurable floors of the isolated asset, as information for the