@@ -477,7 +477,7 @@ three. `--assume-distinct-names` is red only on 5.2.
 </tr>
 <tr>
 <td width="46%" valign="middle">
-<a href="examples/usd-export-evaluation-mode/"><img src="examples/usd-export-evaluation-mode/preview.webp" alt="USD export evaluation_mode: two steel SUBSURF cubes resting on a dark studio floor — left faceted viewport tessellation, right smoother render tessellation, warm wedge on the back wall" /></a>
+<a href="examples/usd-export-evaluation-mode/"><img src="examples/usd-export-evaluation-mode/preview.webp" alt="USD export evaluation_mode: two brass goblets on dark plinths, each re-imported from its own USDA file — left an eight-sided 130-point VIEWPORT export, right a smooth 8450-point RENDER export" /></a>
 </td>
 <td valign="middle">
 
 
@@ -645,7 +645,7 @@
       "name": "usd-export-evaluation-mode",
       "dir": "examples/usd-export-evaluation-mode",
       "teaches": "The USD exporter evaluation_mode chooses viewport versus render modifier quality. TESSELLATE makes the split observable; BEST_MATCH writes the cage and the mode is silent.",
-      "alt": "Two steel balls resting on the floor: a coarse, flat-shaded one on the left and a smooth, subdivided one on the right.",
+      "alt": "Two brass goblets on dark plinths, each re-imported from its own USDA export: an eight-sided 130-point goblet labelled VIEWPORT on the left and a smooth 8450-point goblet labelled RENDER on the right.",
       "witnessesFix": "TESSELLATE+VIEWPORT writes 26/24; TESSELLATE+RENDER writes 98/96 subdivisionScheme=none; BEST_MATCH writes the 8-vert catmullClark cage. --evaluation-mode VIEWPORT and --subdivision BEST_MATCH exit 4.",
       "hero": "docs/gallery/assets/usd-export-evaluation-mode-hero.webp",
       "preview": "examples/usd-export-evaluation-mode/preview.webp",
 
@@ -12,10 +12,19 @@ RENDER writes 98 / 96. Default `export_subdivision='BEST_MATCH'` writes the
 silent — both files are the cage. TESSELLATE is what makes the mode
 observable.
 
-The still is numeric-adjacent: left is viewport tessellation (flat-shaded
-L1), right is render tessellation (smoothed L2). The USDA point counts are
-the evidence; the two balls depict the two qualities the exporter chooses
-between.
+The still shows the exported files themselves. The `--output` path builds a
+turned goblet on an 8-sided lathe cage with SUBSURF `levels=0` /
+`render_levels=3`, exports it twice through the same `wm.usd_export` call
+the check proves (TESSELLATE + VIEWPORT, TESSELLATE + RENDER), re-imports
+both USDA files with `wm.usd_import`, and stages the two imported meshes.
+Left is the VIEWPORT file (the raw 8-sided cage, 130 points), right the
+RENDER file (8450 points). Both are flat-shaded with the same material, so
+geometry is the only difference, and the point count on each placard is
+read from the re-imported mesh at render time. The goblet widens the
+cube's L1/L2 split to L0/L3 so the difference reads at thumbnail size. The
+render path also asserts that the re-imported RENDER goblet is denser than
+the VIEWPORT one (exit 6). Placards use the bundled DejaVu Sans Mono, whose
+`1` cannot be misread as `I`.
 
 **What failure each check would catch:**
 
@@ -26,11 +35,9 @@ between.
 - exit 5 — BEST_MATCH stopped writing the cage
 - exit 6 — RENDER and VIEWPORT files are identical
 
-Staging: Catmull-Clark pulls the surface inside the 2 m cage, and level 1
-and level 2 shrink by different amounts, so both balls used to hover about
-0.16 m over the floor at the cage's z = 1.0. The render path now rests each
-one on the floor from its own evaluated vertices (measured zmin 0.000000
-for both), after the check has run.
+Staging: Catmull-Clark pulls the surface inside the cage, and each level
+shrinks it by a different amount, so each re-imported goblet is seated on
+its plinth from its own vertices rather than from the cage's z.
 
 Probed on the CI Linux portables **Blender 5.2.1 LTS** (`9e2066aef7ef`) and
 **Blender 4.5.13 LTS** (`daeeeca98fb0`): `wm.usd_export` exists, `poll()` is
@@ -58,7 +65,7 @@ against it. `10` is the shared framing helper.
 | 3 | VIEWPORT TESSELLATE point/face count off closed form |
 | 4 | RENDER TESSELLATE point/face count or scheme off closed form |
 | 5 | BEST_MATCH cage point count or scheme off |
-| 6 | RENDER and VIEWPORT USDA point counts are identical |
+| 6 | RENDER and VIEWPORT USDA point counts are identical (check), or the re-imported RENDER goblet is not denser than the VIEWPORT one (`--output`) |
 | 10 | Gallery framing violation |
 | 12 | `--output` produced no file |
 
 
@@ -18,7 +18,7 @@
     blender --background --python usd_export_evaluation_mode.py -- --output u.png
 """
 import bpy, bmesh, sys, os, math, argparse, tempfile
-from mathutils import Vector
+from mathutils import Matrix, Vector
 
 sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir))
 sys.dont_write_bytecode = True
@@ -199,43 +199,214 @@ def principled(name, color, metallic, roughness):
     return mat
 
 
+# Gallery subject: a turned goblet whose coarse lathe cage (GOBLET_SEGS
+# around) carries the same SUBSURF split as the check's cube. The render path
+# exports it twice through the same exporter call the check proves, then
+# re-imports both USDA files — the still shows the files, not the modifier.
+GOBLET_SEGS = 8
+# The goblet widens the gap the check proves on the cube (levels 1 vs 2): an
+# 8-sided cage at viewport level 0 against render level 3, so the difference
+# between the two files reads at thumbnail size.
+GOBLET_VP = 0
+GOBLET_RD = 3
+GOBLET_PROFILE = [            # (r, z) bottom -> rim outside -> rim inside -> well
+    (0.0, 0.0), (0.62, 0.0), (0.66, 0.06), (0.52, 0.14), (0.20, 0.26),
+    (0.14, 0.52), (0.24, 0.64), (0.13, 0.76), (0.15, 1.02), (0.46, 1.16),
+    (0.72, 1.46), (0.80, 1.86), (0.84, 2.14), (0.78, 2.16),
+    (0.72, 1.88), (0.62, 1.52), (0.40, 1.30), (0.0, 1.24),
+]
+
+
+def build_goblet():
+    me = bpy.data.meshes.new("Goblet")
+    bm = bmesh.new()
+    try:
+        rings = []
+        for r, z in GOBLET_PROFILE:
+            if r == 0.0:
+                rings.append([bm.verts.new((0.0, 0.0, z))])
+            else:
+                rings.append([bm.verts.new((r * math.cos(2 * math.pi * s / GOBLET_SEGS),
+                                            r * math.sin(2 * math.pi * s / GOBLET_SEGS), z))
+                              for s in range(GOBLET_SEGS)])
+        for a, b in zip(rings, rings[1:]):
+            for s in range(GOBLET_SEGS):
+                t = (s + 1) % GOBLET_SEGS
+                if len(a) == 1:
+                    bm.faces.new((a[0], b[t], b[s]))
+                elif len(b) == 1:
+                    bm.faces.new((a[s], a[t], b[0]))
+                else:
+                    bm.faces.new((a[s], a[t], b[t], b[s]))
+        bmesh.ops.recalc_face_normals(bm, faces=bm.faces)
+        bm.to_mesh(me)
+    finally:
+        bm.free()
+    ob = bpy.data.objects.new("Goblet", me)
+    bpy.context.collection.objects.link(ob)
+    mod = ob.modifiers.new("Subsurf", "SUBSURF")
+    mod.levels = GOBLET_VP
+    mod.render_levels = GOBLET_RD
+    return ob
+
+
+def label_font():
+    """DejaVu Sans Mono ships in datafiles/fonts on 4.5 and 5.2, and its 1 never
+    reads as I. (Inter ships too, but it is a variable font whose overlapping
+    contours render with holes on 4.5.)"""
+    # system_resource resolves directories only; a file path returns ''
+    fonts = bpy.utils.system_resource("DATAFILES", path="fonts")
+    path = os.path.join(fonts, "DejaVuSansMono.woff2") if fonts else ""
+    if path and os.path.exists(path):
+        try:
+            return bpy.data.fonts.load(path, check_existing=True)
+        except RuntimeError:
+            pass
+    return None
+
+
+def import_usda(path):
+    before = set(bpy.data.objects)
+    if bpy.ops.wm.usd_import(filepath=path) != {"FINISHED"}:
+        raise RuntimeError(f"usd_import failed for {path}")
+    meshes = [o for o in set(bpy.data.objects) - before if o.type == "MESH"]
+    if len(meshes) != 1:
+        raise RuntimeError(f"expected one mesh from {path}, got {len(meshes)}")
+    ob = meshes[0]
+    # bake whatever Xform chain the importer built into the mesh, so staging
+    # below starts from identity like any other prop
+    mw = ob.matrix_world.copy()
+    ob.parent = None
+    ob.data.transform(mw)
+    ob.matrix_world = Matrix.Identity(4)
+    return ob
+
+
+def text_plate(name, lines, loc, mat_plate, mat_ink, scene):
+    """A bevelled brass plate leaning back on the floor with engraved text."""
+    pme = bpy.data.meshes.new(name)
+    bm = bmesh.new()
+    try:
+        bmesh.ops.create_cube(bm, size=1.0)
+        for v in bm.verts:
+            v.co.x *= 1.7
+            v.co.y *= 0.06
+            v.co.z *= 0.52
+        bmesh.ops.bevel(bm, geom=list(bm.edges), offset=0.015, segments=2,
+                        affect="EDGES", clamp_overlap=True)
+        bm.to_mesh(pme)
+    finally:
+        bm.free()
+    pme.materials.append(mat_plate)
+    plate = bpy.data.objects.new(name, pme)
+    plate.location = loc
+    plate.rotation_euler = (math.radians(-14), 0.0, 0.0)
+    scene.collection.objects.link(plate)
+    objs = [plate]
+    for i, (body, size) in enumerate(lines):
+        cu = bpy.data.curves.new(f"{name}.T{i}", "FONT")
+        cu.body = body
+        cu.size = size
+        cu.align_x = "CENTER"
+        cu.align_y = "CENTER"
+        cu.extrude = 0.004
+        cu.materials.append(mat_ink)
+        font = label_font()
+        if font is not None:
+            cu.font = font
+        t = bpy.data.objects.new(f"{name}.T{i}", cu)
+        t.parent = plate
+        t.location = (0.0, -0.065, 0.10 if i == 0 else -0.14)
+        t.rotation_euler = (math.radians(90), 0.0, 0.0)
+        scene.collection.objects.link(t)
+        objs.append(t)
+    return objs
+
+
 def render_still(obj, path, engine):
-    """Left: viewport tessellation (levels=1). Right: render tessellation (levels=2)."""
+    """Left: the VIEWPORT USDA re-imported. Right: the RENDER USDA re-imported."""
+    bpy.ops.wm.read_factory_settings(use_empty=True)
     scene = bpy.context.scene
-    steel = principled("Steel", (0.55, 0.57, 0.60, 1.0), 1.0, 0.58)
-
-    left = obj
-    left.location = (-1.55, 0.0, 1.0)
-    left.rotation_euler = (0.0, 0.0, math.radians(28))
-    left.data.materials.append(steel)
-    left.modifiers["Subsurf"].levels = LEVEL_VP
-    for poly in left.data.polygons:
-        poly.use_smooth = False
-
-    right_me = left.data.copy()
-    right = bpy.data.objects.new("IngotRender", right_me)
-    right.location = (1.55, 0.0, 1.0)
-    right.rotation_euler = (0.0, 0.0, math.radians(28))
-    right.data.materials.append(steel)
-    bpy.context.collection.objects.link(right)
-    rm = right.modifiers.new("Subsurf", "SUBSURF")
-    rm.levels = LEVEL_RD
-    rm.render_levels = LEVEL_RD
-    for poly in right.data.polygons:
-        poly.use_smooth = True
-    # Subdivision pulls the surface inside the 2 m cage, so at z = 1.0 both
-    # ingots hovered above the floor. Rest each on z = 0 from its own
-    # evaluated bounds (level 1 and level 2 shrink by different amounts).
-    bpy.context.view_layer.update()
-    dg = bpy.context.evaluated_depsgraph_get()
-    for ob in (left, right):
-        ev = ob.evaluated_get(dg)
-        em = ev.to_mesh()
+
+    goblet = build_goblet()
+    out_dir = tempfile.mkdtemp(prefix="bdt_usd_goblet_")
+    p_vp = os.path.join(out_dir, "goblet_viewport.usda")
+    p_rd = os.path.join(out_dir, "goblet_render.usda")
+    export_usda(p_vp, "VIEWPORT", "TESSELLATE")
+    export_usda(p_rd, "RENDER", "TESSELLATE")
+    bpy.data.objects.remove(goblet)
+    left = import_usda(p_vp)
+    right = import_usda(p_rd)
+    n_vp, n_rd = len(left.data.vertices), len(right.data.vertices)
+    print(f"goblet usda points viewport={n_vp} render={n_rd}")
+    if n_rd <= n_vp:
+        print("ERROR: re-imported RENDER goblet is not denser than VIEWPORT", file=sys.stderr)
+        return 6
+
+    pewter = principled("Brass", (0.92, 0.64, 0.30, 1.0), 1.0, 0.30)
+    stone = principled("Plinth", (0.06, 0.062, 0.07, 1.0), 0.0, 0.34)
+    plate_mat = principled("Plate", (0.035, 0.036, 0.04, 1.0), 0.7, 0.42)
+    ink = principled("Inlay", (0.95, 0.70, 0.36, 1.0), 1.0, 0.32)
+
+    # turned plinths: a stepped drum per goblet, the goblet seated on top
+    PLINTH_H = 0.62
+    plinths = []
+    for x in (-1.75, 1.75):
+        me = bpy.data.meshes.new("Plinth")
+        bm = bmesh.new()
         try:
-            zmin = min((ev.matrix_world @ v.co).z for v in em.vertices)
+            prof = [(0.0, 0.0), (1.12, 0.0), (1.16, 0.04), (1.16, 0.16), (1.10, 0.20),
+                    (1.02, 0.22), (1.02, PLINTH_H - 0.06), (1.06, PLINTH_H - 0.03),
+                    (1.06, PLINTH_H), (0.0, PLINTH_H)]
+            rings = []
+            for r, z in prof:
+                rings.append([bm.verts.new((0.0, 0.0, z))] if r == 0.0 else
+                             [bm.verts.new((r * math.cos(2 * math.pi * s / 64),
+                                            r * math.sin(2 * math.pi * s / 64), z))
+                              for s in range(64)])
+            for a, b in zip(rings, rings[1:]):
+                for s in range(64):
+                    t = (s + 1) % 64
+                    if len(a) == 1:
+                        f = bm.faces.new((a[0], b[t], b[s]))
+                    elif len(b) == 1:
+                        f = bm.faces.new((a[s], a[t], b[0]))
+                    else:
+                        f = bm.faces.new((a[s], a[t], b[t], b[s]))
+                    f.smooth = True
+            bmesh.ops.recalc_face_normals(bm, faces=bm.faces)
+            bm.to_mesh(me)
         finally:
-            ev.to_mesh_clear()
-        ob.location.z -= zmin
+            bm.free()
+        me.set_sharp_from_angle(angle=math.radians(40.0))
+        me.materials.append(stone)
+        pl = bpy.data.objects.new("Plinth", me)
+        pl.location = (x, 0.0, 0.0)
+        scene.collection.objects.link(pl)
+        plinths.append(pl)
+
+    # Both goblets are shaded identically (flat) — the only difference in the
+    # picture is the geometry each USDA file carries.
+    for ob, x in ((left, -1.75), (right, 1.75)):
+        ob.data.materials.clear()
+        ob.data.materials.append(pewter)
+        for poly in ob.data.polygons:
+            poly.use_smooth = False
+        ob.location = (x, 0.0, 0.0)
+        ob.rotation_euler = (0.0, 0.0, math.radians(11.25))
+        ob.scale = (1.0, 1.0, 1.0)
+    # Subdivision pulls the surface inside the cage by a level-dependent
+    # amount, so each goblet is seated on its plinth from its own verts.
+    bpy.context.view_layer.update()
+    for ob in (left, right):
+        zmin = min((ob.matrix_world @ v.co).z for v in ob.data.vertices)
+        ob.location.z += PLINTH_H - zmin
+
+    labels = []
+    labels += text_plate("PlacardVP", [("VIEWPORT", 0.30), (f"{n_vp} points", 0.17)],
+                         (-1.75, -1.45, 0.30), plate_mat, ink, scene)
+    labels += text_plate("PlacardRD", [("RENDER", 0.30), (f"{n_rd} points", 0.17)],
+                         (1.75, -1.45, 0.30), plate_mat, ink, scene)
 
     floor_me = bpy.data.meshes.new("Floor")
     bm = bmesh.new()
@@ -269,18 +440,23 @@ def light(name, loc, energy, size, col, rot):
         ob.rotation_euler = tuple(math.radians(a) for a in rot)
         scene.collection.objects.link(ob)
 
-    light("Key", (-4.0, -5.0, 6.0), 420.0, 5.0, (1.0, 0.96, 0.9), (46, 0, -35))
-    light("Fill", (5.0, -3.5, 3.0), 180.0, 9.0, (0.75, 0.85, 1.0), (62, 0, 50))
-    light("Wedge", (2.5, 5.5, 4.0), 360.0, 6.0, (1.0, 0.76, 0.5), (-68, 0, 190))
+    light("Key", (-4.0, -5.0, 6.0), 520.0, 3.5, (1.0, 0.95, 0.88), (46, 0, -35))
+    light("Fill", (5.0, -3.5, 3.0), 90.0, 9.0, (0.75, 0.85, 1.0), (62, 0, 50))
+    light("Rim", (0.0, 4.0, 5.5), 260.0, 4.0, (0.62, 0.78, 1.0), (-42, 0, 180))
+    light("Wedge", (2.5, 5.5, 4.0), 520.0, 6.0, (1.0, 0.72, 0.45), (-68, 0, 190))
+    # a broad warm card low and front-left: polished brass mirrors its
+    # surroundings, and on a near-black stage it otherwise reads olive-dark.
+    # The card's reflection is also what draws each facet on the viewport cup.
+    light("Card", (-3.2, -4.2, 2.0), 380.0, 5.0, (1.0, 0.82, 0.6), (72, 0, -38))
 
     aim = bpy.data.objects.new("Aim", None)
-    aim.location = (0.0, 0.0, 0.78)
+    aim.location = (0.0, 0.0, 1.25)
     aim.hide_render = True
     scene.collection.objects.link(aim)
     cam_data = bpy.data.cameras.new("Cam")
     cam_data.lens = 50.0
     cam = bpy.data.objects.new("Cam", cam_data)
-    cam.location = (4.16, -5.85, 3.00)
+    cam.location = (1.05, -10.6, 3.7)
     scene.collection.objects.link(cam)
     scene.camera = cam
     track = cam.constraints.new("TRACK_TO")
@@ -303,7 +479,8 @@ def light(name, loc, energy, size, col, rot):
     scene.view_settings.view_transform = "Standard"
 
     fcode = gallery_framing.check_framing(
-        scene, cam, hero=[left, right], elements=[left, right], stage=[floor, wall],
+        scene, cam, hero=[left, right] + plinths, elements=[left, right] + plinths + labels,
+        stage=[floor, wall],
     )
     if fcode:
         return fcode