diff --git a/README.md b/README.md
index d2d162e..071920e 100644
--- a/README.md
+++ b/README.md
@@ -310,7 +310,7 @@ consumed-input compositing contract, and a save/reload round-trip.
 </tr>
 <tr>
 <td width="46%" valign="middle">
-<a href="examples/light-link-studio/"><img src="examples/light-link-studio/preview.webp" alt="Light link studio: a blazing orange hero sphere beside a dim steel decoy on a dark studio floor, upright LINKED and UNLINKED plaques below each, a warm light pool raking the wall behind - one key light restricted to the hero collection" /></a>
+<a href="examples/light-link-studio/"><img src="examples/light-link-studio/preview.webp" alt="Light link studio: a blazing orange hero sphere and a dim steel decoy staged as specimens on turned-metal pedestals, LINKED and UNLINKED placards on each plinth, a warm floor inlay glowing under the hero only, a warm light pool raking the wall behind - one key light restricted to the hero collection" /></a>
 </td>
 <td valign="middle">
 
@@ -326,7 +326,7 @@ honors linking too (measured), with Cycles pinned for deterministic samples.
 </tr>
 <tr>
 <td width="46%" valign="middle">
-<a href="examples/vse-gamma-cross/"><img src="examples/vse-gamma-cross/preview.webp" alt="VSE gamma cross: a mixing bench in a dark studio - four large emissive panels fading crimson to teal across the cross, with the true midpoint swatch beside the brighter naive-lerp midpoint framed in hazard orange at frame center" /></a>
+<a href="examples/vse-gamma-cross/"><img src="examples/vse-gamma-cross/preview.webp" alt="VSE gamma cross: a calibration lightbox in a dark studio - four backlit chips fading crimson to teal set into bezels on a bolted steel swatch board, with the true midpoint chip beside the brighter naive-lerp midpoint framed in hazard orange, shot at a three-quarter angle" /></a>
 </td>
 <td valign="middle">
 
diff --git a/docs/gallery/assets/light-link-studio-hero.webp b/docs/gallery/assets/light-link-studio-hero.webp
index 25ac8dc..ca53cca 100644
Binary files a/docs/gallery/assets/light-link-studio-hero.webp and b/docs/gallery/assets/light-link-studio-hero.webp differ
diff --git a/docs/gallery/assets/vse-gamma-cross-hero.webp b/docs/gallery/assets/vse-gamma-cross-hero.webp
index 007ce70..7d3c6cc 100644
Binary files a/docs/gallery/assets/vse-gamma-cross-hero.webp and b/docs/gallery/assets/vse-gamma-cross-hero.webp differ
diff --git a/docs/gallery/contact-sheets/light-link-studio-contact-sheet.webp b/docs/gallery/contact-sheets/light-link-studio-contact-sheet.webp
index 145fd82..a80ebe4 100644
Binary files a/docs/gallery/contact-sheets/light-link-studio-contact-sheet.webp and b/docs/gallery/contact-sheets/light-link-studio-contact-sheet.webp differ
diff --git a/docs/gallery/contact-sheets/vse-gamma-cross-contact-sheet.webp b/docs/gallery/contact-sheets/vse-gamma-cross-contact-sheet.webp
index e5b1816..0b04aff 100644
Binary files a/docs/gallery/contact-sheets/vse-gamma-cross-contact-sheet.webp and b/docs/gallery/contact-sheets/vse-gamma-cross-contact-sheet.webp differ
diff --git a/docs/gallery/index.html b/docs/gallery/index.html
index 59f0b8b..1954e0a 100644
--- a/docs/gallery/index.html
+++ b/docs/gallery/index.html
@@ -530,8 +530,8 @@ <h2><a href="vse-gamma-cross/">vse-gamma-cross</a></h2>
         </a>
         <div class="card-body">
           <h2><a href="light-link-studio/">light-link-studio</a></h2>
-          <p class="teaches">One key, one hero: a light linked to a receiver collection lights only the hero, proven by two pixel renders in one pass. Linked: 3.6x luminance ratio; unlinked in the same check: the decoy rises 206% while the hero holds at 0.0% drift.</p>
-          <p class="witnesses"><span class="tag">witnesses</span> The API is obj.light_linking on the light OBJECT (ld.light_linking is an AttributeError). Luminance is sampled at each sphere&#x27;s projected center; EEVEE honors linking too (probe-measured 3.7x on 4.5.11 EEVEE Next and 5.1.2 EEVEE), Cycles pinned for deterministic samples.</p>
+          <p class="teaches">One key, one hero: a light linked to a receiver collection lights only the hero, proven by two pixel renders in one pass. Linked: 3.6x luminance ratio; unlinked in the same check: the decoy rises 233% while the hero holds at 0.3% drift.</p>
+          <p class="witnesses"><span class="tag">witnesses</span> The API is obj.light_linking on the light OBJECT (ld.light_linking is an AttributeError). Luminance is sampled at each sphere&#x27;s projected center; EEVEE honors linking too (probe-measured 3.8x on 4.5.11 EEVEE Next and 5.1.2 EEVEE), Cycles pinned for deterministic samples.</p>
           <a class="card-link" href="light-link-studio/">View example <span aria-hidden="true">&rarr;</span></a>
         </div>
       </article>
diff --git a/docs/gallery/light-link-studio/index.html b/docs/gallery/light-link-studio/index.html
index 0debdd8..f858e77 100644
--- a/docs/gallery/light-link-studio/index.html
+++ b/docs/gallery/light-link-studio/index.html
@@ -4,18 +4,18 @@
   <meta charset="utf-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1" />
   <title>light-link-studio — Examples — Blender Developer Tools</title>
-  <meta name="description" content="One key, one hero: a light linked to a receiver collection lights only the hero, proven by two pixel renders in one pass. Linked: 3.6x luminance ratio; unlinked in the same check: the decoy rises 206% while the hero holds at 0.0% drift." />
+  <meta name="description" content="One key, one hero: a light linked to a receiver collection lights only the hero, proven by two pixel renders in one pass. Linked: 3.6x luminance ratio; unlinked in the same check: the decoy rises 233% while the hero holds at 0.3% drift." />
   <link rel="canonical" href="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/light-link-studio/" />
   <link rel="icon" href="../../assets/favicon.svg" type="image/svg+xml" />
   <meta name="theme-color" content="#1a1b1e" />
   <meta property="og:type" content="website" />
   <meta property="og:title" content="light-link-studio — Examples — Blender Developer Tools" />
-  <meta property="og:description" content="One key, one hero: a light linked to a receiver collection lights only the hero, proven by two pixel renders in one pass. Linked: 3.6x luminance ratio; unlinked in the same check: the decoy rises 206% while the hero holds at 0.0% drift." />
+  <meta property="og:description" content="One key, one hero: a light linked to a receiver collection lights only the hero, proven by two pixel renders in one pass. Linked: 3.6x luminance ratio; unlinked in the same check: the decoy rises 233% while the hero holds at 0.3% drift." />
   <meta property="og:url" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/light-link-studio/" />
   <meta property="og:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/light-link-studio-hero.webp" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="light-link-studio — Examples — Blender Developer Tools" />
-  <meta name="twitter:description" content="One key, one hero: a light linked to a receiver collection lights only the hero, proven by two pixel renders in one pass. Linked: 3.6x luminance ratio; unlinked in the same check: the decoy rises 206% while the hero holds at 0.0% drift." />
+  <meta name="twitter:description" content="One key, one hero: a light linked to a receiver collection lights only the hero, proven by two pixel renders in one pass. Linked: 3.6x luminance ratio; unlinked in the same check: the decoy rises 233% while the hero holds at 0.3% drift." />
   <meta name="twitter:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/light-link-studio-hero.webp" />
   <style>
     /* fonts are deployed by the landing build (docs/fonts/) */
@@ -170,14 +170,14 @@
   </div>
   <header class="hero">
     <h1>light-link-studio</h1>
-    <p>One key, one hero: a light linked to a receiver collection lights only the hero, proven by two pixel renders in one pass. Linked: 3.6x luminance ratio; unlinked in the same check: the decoy rises 206% while the hero holds at 0.0% drift.</p>
+    <p>One key, one hero: a light linked to a receiver collection lights only the hero, proven by two pixel renders in one pass. Linked: 3.6x luminance ratio; unlinked in the same check: the decoy rises 233% while the hero holds at 0.3% drift.</p>
   </header>
   <main id="main">
     <button class="detail-hero" id="heroZoom" type="button" aria-label="Zoom light-link-studio render">
       <img src="../assets/light-link-studio-hero.webp" alt="light-link-studio render" 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> The API is obj.light_linking on the light OBJECT (ld.light_linking is an AttributeError). Luminance is sampled at each sphere&#x27;s projected center; EEVEE honors linking too (probe-measured 3.7x on 4.5.11 EEVEE Next and 5.1.2 EEVEE), Cycles pinned for deterministic samples.</div>
+    <div class="callout"><span class="tag">witnesses</span> The API is obj.light_linking on the light OBJECT (ld.light_linking is an AttributeError). Luminance is sampled at each sphere&#x27;s projected center; EEVEE honors linking too (probe-measured 3.8x on 4.5.11 EEVEE Next and 5.1.2 EEVEE), Cycles pinned for deterministic samples.</div>
     <div class="runline">
       <pre id="runCmd">blender --background --python examples/light-link-studio/light_link_studio.py --</pre>
       <button class="copy-btn" id="copyRun" type="button">Copy</button>
@@ -185,10 +185,10 @@ <h1>light-link-studio</h1>
     <section class="detail-section md">
 <p>A runnable example that stages one key light linked to a hero sphere beside an identical decoy, renders the studio twice in one pass, and proves the whole light-linking contract <strong>in pixels</strong> — the feature AI-generated staging code most often misses or misaddresses.</p>
 <p><strong>What it witnesses:</strong> the light-linking contract and the traps around it.</p>
-<ul><li><strong>The API is on the light OBJECT, not the Light datablock.</strong> <code>ld.light_linking</code> is an AttributeError on both versions (verified); the path is <code>obj.light_linking.receiver_collection</code> (ObjectLightLinking, with <code>blocker_collection</code> alongside). Assignment reads back through the API.</li><li><strong>Linked, the key lights only the receiver collection.</strong> Render one: hero well-lit, decoy at the fill floor — hero/decoy luminance ratio <strong>3.6x</strong> (gate ≥ 3x), measured at each sphere&#x27;s <strong>projected</strong> center so framing can&#x27;t move the sample off the subject.</li><li><strong>Unlinked (same check), the restriction vanishes surgically.</strong> Render two: the decoy rises <strong>206–213%</strong> while the hero drifts <strong>0.0%</strong> — the link restricts without dimming anything else. The shipped check therefore demonstrates both states, not just one. The rise figure is noisy by construction: the decoy&#x27;s unlit base sits near the fill floor, so small absolute shifts in that base swing the relative rise between versions and runs — the gate is a conservative ≥ 50%.</li><li><strong>The engine note, verified rather than assumed.</strong> Light linking also works on EEVEE — measured with an EEVEE luminance probe (the shipped scene with <code>render.engine</code> swapped: <code>BLENDER_EEVEE</code> on 5.x, <code>BLENDER_EEVEE_NEXT</code> on 4.x) at <strong>3.7x</strong> linked ratio on both 4.5.11 EEVEE Next and 5.1.2 EEVEE, matching Cycles within sampling noise. The shipped check still pins Cycles for deterministic tiny-sample CPU renders; luminance gates need <code>view_transform = &#x27;Standard&#x27;</code> (AgX compresses the ratios).</li></ul>
+<ul><li><strong>The API is on the light OBJECT, not the Light datablock.</strong> <code>ld.light_linking</code> is an AttributeError on both versions (verified); the path is <code>obj.light_linking.receiver_collection</code> (ObjectLightLinking, with <code>blocker_collection</code> alongside). Assignment reads back through the API.</li><li><strong>Linked, the key lights only the receiver collection.</strong> Render one: hero well-lit, decoy at the fill floor — hero/decoy luminance ratio <strong>3.6x</strong> (gate ≥ 3x), measured at each sphere&#x27;s <strong>projected</strong> center so framing can&#x27;t move the sample off the subject.</li><li><strong>Unlinked (same check), the restriction vanishes surgically.</strong> Render two: the decoy rises <strong>233–238%</strong> while the hero drifts <strong>0.1–0.3%</strong> — the link restricts without dimming anything else. The shipped check therefore demonstrates both states, not just one. The rise figure is noisy by construction: the decoy&#x27;s unlit base sits near the fill floor, so small absolute shifts in that base swing the relative rise between versions and runs — the gate is a conservative ≥ 50%.</li><li><strong>The engine note, verified rather than assumed.</strong> Light linking also works on EEVEE — measured with an EEVEE luminance probe (the shipped scene with <code>render.engine</code> swapped: <code>BLENDER_EEVEE</code> on 5.x, <code>BLENDER_EEVEE_NEXT</code> on 4.x) at <strong>3.8x</strong> linked ratio on both 4.5.11 EEVEE Next and 5.1.2 EEVEE, matching Cycles within sampling noise. The shipped check still pins Cycles for deterministic tiny-sample CPU renders; luminance gates need <code>view_transform = &#x27;Standard&#x27;</code> (AgX compresses the ratios).</li></ul>
 <p><strong>What each check catches on failure:</strong> inverting the link to the decoy collection (exit 6 — hero/decoy ratio collapses to 0.39x), an RNA move of the API onto the Light datablock (exit 3, guarded), a lost assignment read-back (exit 5), a link that doesn&#x27;t restrict (exit 7, rise below 50%), and a non-surgical restriction (exit 8, hero drift above 5%).</p>
-<p><strong>Version witness:</strong> ObjectLightLinking API and the measured ratios match on Blender 4.5 LTS and 5.1 (3.4x vs 3.6x linked; rise 213% vs 206% — inside the rise noise described above).</p>
-<p>The render is the contract at a glance: the blazing orange hero over the LINKED plaque, the cold steel decoy over UNLINKED, a warm pool raking the wall behind them — one key, one hero.</p>
+<p><strong>Version witness:</strong> ObjectLightLinking API and the measured ratios match on Blender 4.5 LTS and 5.1 (3.7x vs 3.6x linked; rise 238% vs 233% — inside the rise noise described above).</p>
+<p>The render is the contract at a glance: the spheres staged as studio specimens on matching turned-metal pedestals — the blazing orange hero over its LINKED placard with the warm floor inlay marking the linked light&#x27;s footprint, the cold steel decoy over UNLINKED with its inlay dark, a warm pool raking the wall behind them — one key, one hero.</p>
 <h2>Run</h2>
 <pre><code># Two-render correctness check (tiny Cycles CPU renders) — the CI check:
 blender --background --python light_link_studio.py --
@@ -219,7 +219,7 @@ <h2>Source</h2>
 The engine note, verified rather than assumed: light linking also works on
 EEVEE — measured with an EEVEE luminance probe (this scene, only
 ``render.engine`` swapped: ``BLENDER_EEVEE`` on 5.x, ``BLENDER_EEVEE_NEXT``
-on 4.x) at 3.7x linked ratio on both 4.5.11 EEVEE Next and 5.1.2 EEVEE,
+on 4.x) at 3.8x linked ratio on both 4.5.11 EEVEE Next and 5.1.2 EEVEE,
 matching Cycles within sampling noise. The shipped check pins Cycles for
 deterministic tiny-sample CPU renders. The API is stable between Blender
 4.5 LTS and 5.1 (ObjectLightLinking with
@@ -232,11 +232,13 @@ <h2>Source</h2>
     blender --background --python light_link_studio.py -- --output l.png  # + render
 &quot;&quot;&quot;</span>
 <span class="k">import</span> bpy, bmesh, sys, os, math, argparse, tempfile, shutil
+<span class="k">from</span> mathutils <span class="k">import</span> Matrix
 
 HERO_RGB = (<span class="n">0.85</span>, <span class="n">0.30</span>, <span class="n">0.08</span>)     <span class="c"># hazard orange</span>
 DECOY_RGB = (<span class="n">0.30</span>, <span class="n">0.34</span>, <span class="n">0.40</span>)    <span class="c"># cold steel</span>
 KEY_ENERGY = <span class="n">560.0</span>
 FILL_ENERGY = <span class="n">26.0</span>
+SPHERE_Z = <span class="n">1.18</span>                   <span class="c"># center: sphere rests on the pedestal cap</span>
 PXW, PXH = <span class="n">64</span>, <span class="n">36</span>
 RATIO_MIN = <span class="n">3.0</span>                   <span class="c"># hero/decoy luminance ratio, linked</span>
 HERO_LUMA_MIN = <span class="n">0.25</span>              <span class="c"># hero must be well-lit, linked</span>
@@ -261,11 +263,90 @@ <h2>Source</h2>
     b.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.55</span>
     me.materials.append(mat)
     ob = bpy.data.objects.new(name, me)
-    ob.location = (x, <span class="n">0.0</span>, <span class="n">0.55</span>)
+    ob.location = (x, <span class="n">0.0</span>, SPHERE_Z)
     coll.objects.link(ob)
     <span class="k">return</span> ob
 
 
+<span class="k">def</span> _principled(name, rgb, rough, metallic=<span class="n">0.0</span>, emit=<span class="k">None</span>, estr=<span class="n">0.0</span>):
+    mat = bpy.data.materials.new(name)
+    mat.use_nodes = <span class="k">True</span>
+    b = mat.node_tree.nodes[<span class="s">&quot;Principled BSDF&quot;</span>]
+    b.inputs[<span class="s">&quot;Base Color&quot;</span>].default_value = (*rgb, <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 = metallic
+    <span class="k">if</span> emit <span class="k">is</span> <span class="k">not</span> <span class="k">None</span>:
+        sock = b.inputs.get(<span class="s">&quot;Emission Color&quot;</span>) <span class="k">or</span> b.inputs[<span class="s">&quot;Emission&quot;</span>]
+        sock.default_value = (*emit, <span class="n">1.0</span>)
+        b.inputs[<span class="s">&quot;Emission Strength&quot;</span>].default_value = estr
+    <span class="k">return</span> mat
+
+
+<span class="k">def</span> _bevel(ob, width, segments=<span class="n">2</span>):
+    mod = ob.modifiers.new(<span class="s">&quot;Bev&quot;</span>, <span class="s">&#x27;BEVEL&#x27;</span>)
+    mod.width = width
+    mod.segments = segments
+    mod.limit_method = <span class="s">&#x27;ANGLE&#x27;</span>
+
+
+<span class="k">def</span> _cyl(sc, name, r1, r2, depth, loc, mat, bevel=<span class="n">0.0</span>):
+    me = bpy.data.meshes.new(name)
+    bm = bmesh.new()
+    <span class="k">try</span>:
+        bmesh.ops.create_cone(bm, cap_ends=<span class="k">True</span>, cap_tris=<span class="k">False</span>,
+                              segments=<span class="n">48</span>, radius1=r1, radius2=r2, depth=depth)
+        bm.to_mesh(me)
+    <span class="k">finally</span>:
+        bm.free()
+    me.update()
+    <span class="k">for</span> p <span class="k">in</span> me.polygons:       <span class="c"># smooth the wall, keep the caps flat</span>
+        p.use_smooth = abs(p.normal.z) &lt; <span class="n">0.5</span>
+    me.materials.append(mat)
+    ob = bpy.data.objects.new(name, me)
+    ob.location = loc
+    sc.collection.objects.link(ob)
+    <span class="k">if</span> bevel:
+        _bevel(ob, bevel)
+    <span class="k">return</span> ob
+
+
+<span class="k">def</span> _box(sc, name, dims, loc, mat, bevel=<span class="n">0.0</span>, parent=<span class="k">None</span>):
+    me = bpy.data.meshes.new(name)
+    bm = bmesh.new()
+    <span class="k">try</span>:
+        bmesh.ops.create_cube(bm, size=<span class="n">1.0</span>)
+        bmesh.ops.transform(bm, matrix=Matrix.Diagonal((*dims, <span class="n">1.0</span>)),
+                            verts=bm.verts)
+        bm.to_mesh(me)
+    <span class="k">finally</span>:
+        bm.free()
+    me.materials.append(mat)
+    ob = bpy.data.objects.new(name, me)
+    ob.location = loc
+    <span class="k">if</span> parent <span class="k">is</span> <span class="k">not</span> <span class="k">None</span>:
+        ob.parent = parent
+    sc.collection.objects.link(ob)
+    <span class="k">if</span> bevel:
+        _bevel(ob, bevel, segments=<span class="n">3</span>)
+    <span class="k">return</span> ob
+
+
+<span class="k">def</span> pedestal(sc, x, dark, metal):
+    <span class="s">&quot;&quot;&quot;A designed specimen plinth: turned foot, dark polymer body with a
+    flat front for the placard, machined collar band, round cap.&quot;&quot;&quot;</span>
+    _cyl(sc, <span class="s">&quot;PedFoot&quot;</span>, <span class="n">0.58</span>, <span class="n">0.54</span>, <span class="n">0.09</span>, (x, <span class="n">0.0</span>, <span class="n">0.045</span>), metal, <span class="n">0.02</span>)
+    _box(sc, <span class="s">&quot;PedBody&quot;</span>, (<span class="n">0.74</span>, <span class="n">0.54</span>, <span class="n">0.50</span>), (x, <span class="n">0.0</span>, <span class="n">0.34</span>), dark, <span class="n">0.05</span>)
+    _box(sc, <span class="s">&quot;PedCollar&quot;</span>, (<span class="n">0.80</span>, <span class="n">0.60</span>, <span class="n">0.05</span>), (x, <span class="n">0.0</span>, <span class="n">0.615</span>), metal, <span class="n">0.015</span>)
+    _cyl(sc, <span class="s">&quot;PedCap&quot;</span>, <span class="n">0.42</span>, <span class="n">0.42</span>, <span class="n">0.06</span>, (x, <span class="n">0.0</span>, <span class="n">0.67</span>), metal, <span class="n">0.02</span>)
+
+
+<span class="k">def</span> floor_inlay(sc, x, mat):
+    <span class="s">&quot;&quot;&quot;Thin disc flush with the floor: the linked light&#x27;s footprint. The
+    hero&#x27;s is emissive warm; the decoy&#x27;s is dark metal — a footprint that
+    never lights, and therefore cannot pollute the decoy&#x27;s fill floor.&quot;&quot;&quot;</span>
+    _cyl(sc, <span class="s">&quot;Inlay&quot;</span>, <span class="n">0.74</span>, <span class="n">0.74</span>, <span class="n">0.014</span>, (x, <span class="n">0.0</span>, <span class="n">0.007</span>), mat)
+
+
 <span class="k">def</span> add_light(sc, name, energy, loc, color, size, aim=<span class="k">None</span>, rot=<span class="k">None</span>):
     ld = bpy.data.lights.new(name, <span class="s">&#x27;AREA&#x27;</span>)
     ld.energy = energy
@@ -285,7 +366,9 @@ <h2>Source</h2>
 
 
 <span class="k">def</span> build_studio(sc):
-    <span class="s">&quot;&quot;&quot;Hero and decoy on one stage, plus a low fill that lights both.&quot;&quot;&quot;</span>
+    <span class="s">&quot;&quot;&quot;Hero and decoy as specimens on plinths, plus a low fill that lights
+    both. The plinths and inlays are dressing only: the witness is still two
+    identical spheres where one key reaches only the hero.&quot;&quot;&quot;</span>
     hero_c = bpy.data.collections.new(<span class="s">&quot;HeroColl&quot;</span>)
     decoy_c = bpy.data.collections.new(<span class="s">&quot;DecoyColl&quot;</span>)
     hero = sphere(<span class="s">&quot;Hero&quot;</span>, HERO_RGB, -<span class="n">1.2</span>, hero_c)
@@ -293,6 +376,17 @@ <h2>Source</h2>
     sc.collection.children.link(hero_c)
     sc.collection.children.link(decoy_c)
 
+    ped_dark = _principled(<span class="s">&quot;PedDark&quot;</span>, (<span class="n">0.05</span>, <span class="n">0.052</span>, <span class="n">0.06</span>), <span class="n">0.5</span>, metallic=<span class="n">0.15</span>)
+    ped_metal = _principled(<span class="s">&quot;PedMetal&quot;</span>, (<span class="n">0.16</span>, <span class="n">0.17</span>, <span class="n">0.20</span>), <span class="n">0.3</span>, metallic=<span class="n">0.9</span>)
+    pedestal(sc, -<span class="n">1.2</span>, ped_dark, ped_metal)
+    pedestal(sc, <span class="n">1.2</span>, ped_dark, ped_metal)
+    inlay_warm = _principled(<span class="s">&quot;InlayWarm&quot;</span>, (<span class="n">0.02</span>, <span class="n">0.018</span>, <span class="n">0.016</span>), <span class="n">0.6</span>,
+                             emit=(<span class="n">0.85</span>, <span class="n">0.36</span>, <span class="n">0.09</span>), estr=<span class="n">1.1</span>)
+    inlay_dark = _principled(<span class="s">&quot;InlayDark&quot;</span>, (<span class="n">0.07</span>, <span class="n">0.075</span>, <span class="n">0.085</span>), <span class="n">0.35</span>,
+                             metallic=<span class="n">0.85</span>)
+    floor_inlay(sc, -<span class="n">1.2</span>, inlay_warm)
+    floor_inlay(sc, <span class="n">1.2</span>, inlay_dark)
+
     floor_me = bpy.data.meshes.new(<span class="s">&quot;Floor&quot;</span>)
     bm = bmesh.new()
     <span class="k">try</span>:
@@ -338,9 +432,16 @@ <h2>Source</h2>
     cam = bpy.data.cameras.new(<span class="s">&quot;Cam&quot;</span>)
     cam.lens = <span class="n">50.0</span>
     cam_ob = bpy.data.objects.new(<span class="s">&quot;Cam&quot;</span>, cam)
-    cam_ob.location = (<span class="n">0.0</span>, -<span class="n">6.2</span>, <span class="n">2.0</span>)
+    cam_ob.location = (<span class="n">0.0</span>, -<span class="n">6.2</span>, <span class="n">2.3</span>)
+    <span class="c"># the camera frames the raised specimens, the lights keep their own aim —</span>
+    <span class="c"># re-aiming the lights would move the measured luminance. The steeper</span>
+    <span class="c"># down-angle also keeps the decoy&#x27;s fill-floor luminance at its measured</span>
+    <span class="c"># baseline — a flatter camera samples a brighter point on the decoy.</span>
+    cam_aim = bpy.data.objects.new(<span class="s">&quot;CamAim&quot;</span>, <span class="k">None</span>)
+    cam_aim.location = (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.8</span>)
+    sc.collection.objects.link(cam_aim)
     con = cam_ob.constraints.new(<span class="s">&#x27;TRACK_TO&#x27;</span>)
-    con.target = aim
+    con.target = cam_aim
     con.track_axis = <span class="s">&#x27;TRACK_NEGATIVE_Z&#x27;</span>
     con.up_axis = <span class="s">&#x27;UP_Y&#x27;</span>
     sc.collection.objects.link(cam_ob)
@@ -450,33 +551,39 @@ <h2>Source</h2>
     <span class="k">return</span> <span class="n">0</span>
 
 
-<span class="k">def</span> plaque(sc, text, x):
-    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>]
-    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="c"># faint self-glow: the UNLINKED plaque must read even in the decoy&#x27;s dark</span>
-    sock = pb.inputs.get(<span class="s">&quot;Emission Color&quot;</span>) <span class="k">or</span> pb.inputs[<span class="s">&quot;Emission&quot;</span>]
-    sock.default_value = (<span class="n">0.35</span>, <span class="n">0.37</span>, <span class="n">0.42</span>, <span class="n">1.0</span>)
-    pb.inputs[<span class="s">&quot;Emission Strength&quot;</span>].default_value = <span class="n">0.6</span>
-    cu = bpy.data.curves.new(<span class="s">&quot;Plaque&quot;</span>, <span class="s">&#x27;FONT&#x27;</span>)
+<span class="k">def</span> placard(sc, text, x, plate_m, stand_m, text_m):
+    <span class="s">&quot;&quot;&quot;Museum nameplate: a beveled plate on two standoffs bolted to the
+    plinth front, tilted back to face the raised camera, text on its face.&quot;&quot;&quot;</span>
+    root = bpy.data.objects.new(<span class="s">&quot;Placard&quot;</span>, <span class="k">None</span>)
+    root.location = (x, -<span class="n">0.325</span>, <span class="n">0.34</span>)
+    root.rotation_euler = (math.radians(<span class="n">71</span>), <span class="n">0.0</span>, <span class="n">0.0</span>)
+    sc.collection.objects.link(root)
+    _box(sc, <span class="s">&quot;Plate&quot;</span>, (<span class="n">0.92</span>, <span class="n">0.22</span>, <span class="n">0.024</span>), (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>), plate_m,
+         <span class="n">0.012</span>, parent=root)
+    <span class="k">for</span> sx <span class="k">in</span> (-<span class="n">0.30</span>, <span class="n">0.30</span>):
+        _cyl(sc, <span class="s">&quot;Standoff&quot;</span>, <span class="n">0.016</span>, <span class="n">0.016</span>, <span class="n">0.055</span>, (sx, <span class="n">0.0</span>, -<span class="n">0.038</span>),
+             stand_m).parent = root
+    cu = bpy.data.curves.new(<span class="s">&quot;PlacardText&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.22</span>
-    cu.extrude = <span class="n">0.006</span>
-    ob = bpy.data.objects.new(<span class="s">&quot;Plaque&quot;</span>, cu)
-    <span class="c"># standing upright on the floor, tilted back to face the raised camera</span>
-    ob.location = (x, -<span class="n">1.3</span>, <span class="n">0.17</span>)
-    ob.rotation_euler = (math.radians(<span class="n">76</span>), <span class="n">0.0</span>, <span class="n">0.0</span>)
-    ob.data.materials.append(pm)
+    cu.align_y = <span class="s">&#x27;CENTER&#x27;</span>
+    cu.size = <span class="n">0.15</span>
+    cu.extrude = <span class="n">0.004</span>
+    ob = bpy.data.objects.new(<span class="s">&quot;PlacardText&quot;</span>, cu)
+    ob.location = (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.0165</span>)
+    ob.parent = root
+    cu.materials.append(text_m)
     sc.collection.objects.link(ob)
 
 
 <span class="k">def</span> render_still(sc, path):
-    plaque(sc, <span class="s">&quot;LINKED&quot;</span>, -<span class="n">1.2</span>)
-    plaque(sc, <span class="s">&quot;UNLINKED&quot;</span>, <span class="n">1.2</span>)
+    plate_m = _principled(<span class="s">&quot;PlateBlack&quot;</span>, (<span class="n">0.03</span>, <span class="n">0.032</span>, <span class="n">0.038</span>), <span class="n">0.6</span>)
+    stand_m = _principled(<span class="s">&quot;StandMetal&quot;</span>, (<span class="n">0.16</span>, <span class="n">0.17</span>, <span class="n">0.20</span>), <span class="n">0.3</span>, metallic=<span class="n">0.9</span>)
+    <span class="c"># faint self-glow: the UNLINKED placard must read even in the decoy&#x27;s dark</span>
+    text_m = _principled(<span class="s">&quot;PlacardText&quot;</span>, (<span class="n">0.42</span>, <span class="n">0.44</span>, <span class="n">0.48</span>), <span class="n">0.6</span>, metallic=<span class="n">0.2</span>,
+                         emit=(<span class="n">0.35</span>, <span class="n">0.37</span>, <span class="n">0.42</span>), estr=<span class="n">0.6</span>)
+    placard(sc, <span class="s">&quot;LINKED&quot;</span>, -<span class="n">1.2</span>, plate_m, stand_m, text_m)
+    placard(sc, <span class="s">&quot;UNLINKED&quot;</span>, <span class="n">1.2</span>, plate_m, stand_m, text_m)
     <span class="c"># the gallery still is the linked state, on Cycles for the same</span>
     <span class="c"># deterministic sampling as the check</span>
     sc.render.engine = <span class="s">&#x27;CYCLES&#x27;</span>
diff --git a/docs/gallery/vse-gamma-cross/index.html b/docs/gallery/vse-gamma-cross/index.html
index 36993ef..fe6e407 100644
--- a/docs/gallery/vse-gamma-cross/index.html
+++ b/docs/gallery/vse-gamma-cross/index.html
@@ -188,12 +188,12 @@ <h1>vse-gamma-cross</h1>
 <ul><li><strong>The cross blends in a gamma-0.5 space.</strong> Not <code>(1-t)·A + t·B</code> but <code>((1-t)·√A + t·√B)²</code> — the mid-cross dips below the sRGB lerp. From crimson <code>(0.85, 0.10, 0.22)</code> and teal <code>(0.06, 0.75, 0.80)</code> the midpoint is <code>(0.341, 0.349, 0.463)</code>: <strong>0.115 darker</strong> on red than the lerp <code>(0.455, 0.425, 0.510)</code>. The check renders and asserts nine samples (t = 0, 1/8, …, 7/8, 31/32) within 5e-3 (2× the 8-bit quantization step + fit residual; measured 2.93e-3) and that the mid lerp deviation is material (≥0.05).</li><li><strong><code>t = (frame − start) / duration</code>, and it never reaches 1 inside the effect.</strong> The last frame of the span blends at <code>(duration−1)/duration</code>; B arrives only when the effect ends. That final frame (frame 32, t = 31/32) is one of the nine asserted samples, so the convention is pixel-backed end to end. An endpoint-inclusive convention is off by a full frame-step (probe: exit 5 at t 0.129 vs 0.125).</li><li><strong>The pixel witness demands <code>view_transform = &#x27;Standard&#x27;</code></strong> — the factory default AgX tone-maps the samples and poisons the fit (measured 0.146 on the red channel during authoring), the same class of silent failure the gallery&#x27;s render standard exists to prevent. Also caught: deleting a consumed input strip orphans-and-deletes the effect (<code>Strip &#x27;GC&#x27; not in scene</code>) — remove effects before their inputs.</li></ul>
 <p><strong>What each check catches on failure:</strong> asserting the naive lerp as the expectation (exit 6, deviation 0.1138 at mid), the endpoint-inclusive t convention (exit 5), and swapped cross inputs (exit 4, <code>input1=T2</code>).</p>
 <p><strong>Version witness:</strong> the blend math is identical on Blender 4.5 LTS and 5.1 — every sample matches to the quantization step. The creation contract from <code>vse-cut-list</code> still gates the timeline: <code>strips</code> (never <code>.sequences</code>), and <code>new_effect</code> ending in <code>length=</code> on 5.x vs <code>frame_end=</code> on 4.5.</p>
-<p>The render is the bench: the authentic fade as four large emissive panels (t = 0, 1/4, 1/2, 3/4) above the contrast pair at frame center — the true mid swatch directly beside the naive lerp mid, the impostor framed in hazard orange. The gamma dip reads as an adjacency contrast even at card scale: a naive-lerp cross would make the pair identical, so the still visibly breaks with the contract.</p>
+<p>The render is a calibration lightbox: the authentic fade as four backlit chips (t = 0, 1/4, 1/2, 3/4) set into bezels on a bolted steel swatch board — cap rails, panel seam, corner bolts, rear struts down to a plinth — shot at a 3/4 angle so it reads as a staged object. Below the fade row sits the contrast pair: the true mid chip directly beside the naive lerp mid, the impostor framed in hazard orange. The gamma dip reads as an adjacency contrast even at card scale: a naive-lerp cross would make the pair identical, so the still visibly breaks with the contract.</p>
 <h2>Run</h2>
 <pre><code># Correctness check (tiny per-frame sample renders) — the CI check:
 blender --background --python vse_gamma_cross.py --
 
-# Also render the mixing bench still (EEVEE on a GPU host; cycles on GPU-less):
+# Also render the calibration lightbox still (EEVEE on a GPU host; cycles on GPU-less):
 blender --background --python vse_gamma_cross.py -- --output bench.png
 blender --background --python vse_gamma_cross.py -- --output bench.png --engine cycles</code></pre>
 <p>It exits non-zero on failure (span drift, wrong inputs, t-convention drift, a sample off the closed form, or a missing gamma dip). The <code>blender-smoke</code> workflow runs the check on Blender 4.5 LTS and 5.1.</p>
@@ -391,74 +391,119 @@ <h2>Source</h2>
 
 
 <span class="k">def</span> build_bench(sc, got):
-    <span class="s">&quot;&quot;&quot;The mixing bench: the authentic fade as four large emissive panels
-    (t = 0, 1/4, 1/2, 3/4) above the contrast pair — the true mid swatch
-    directly beside the naive lerp mid at frame center, so the gamma dip
-    reads as an adjacency contrast even at card scale. A naive-lerp cross
-    would make the pair identical: the render visibly breaks with the
-    contract.&quot;&quot;&quot;</span>
+    <span class="s">&quot;&quot;&quot;The calibration lightbox: a swatch-booth fixture — glowing chips
+    seated in bezels on a bolted steel board, held by rear struts over a
+    plinth — shot at a 3/4 angle so it reads as a staged object, not a
+    flat test chart. The authentic fade runs as four backlit chips across
+    the top (t = 0, 1/4, 1/2, 3/4); the contrast pair is the centerpiece
+    below: the true mid directly beside the naive lerp mid in its
+    hazard-orange bezel, so the gamma dip reads as an adjacency contrast
+    even at card scale. A naive-lerp cross would make the pair identical:
+    the render visibly breaks with the contract.&quot;&quot;&quot;</span>
     <span class="k">import</span> bmesh
     <span class="k">import</span> mathutils
     <span class="k">import</span> math <span class="k">as</span> m
 
-    <span class="k">def</span> panel(name, rgb, x, z, y=<span class="n">0.0</span>, hot=<span class="k">False</span>):
-        mat = bpy.data.materials.new(<span class="s">f&quot;</span><span class="s">Swatch</span>{name}<span class="s">&quot;</span>)
+    <span class="k">def</span> mat_principled(name, color, metallic, rough):
+        mat = bpy.data.materials.new(name)
         mat.use_nodes = <span class="k">True</span>
-        nt = mat.node_tree
-        nt.nodes.clear()
-        out = nt.nodes.new(<span class="s">&quot;ShaderNodeOutputMaterial&quot;</span>)
-        em = nt.nodes.new(<span class="s">&quot;ShaderNodeEmission&quot;</span>)
-        em.inputs[<span class="s">&quot;Color&quot;</span>].default_value = (*rgb, <span class="n">1.0</span>)
-        em.inputs[<span class="s">&quot;Strength&quot;</span>].default_value = <span class="n">1.0</span>
-        nt.links.new(em.outputs[<span class="s">&quot;Emission&quot;</span>], out.inputs[<span class="s">&quot;Surface&quot;</span>])
+        bsdf = mat.node_tree.nodes[<span class="s">&quot;Principled BSDF&quot;</span>]
+        bsdf.inputs[<span class="s">&quot;Base Color&quot;</span>].default_value = (*color, <span class="n">1.0</span>)
+        bsdf.inputs[<span class="s">&quot;Metallic&quot;</span>].default_value = metallic
+        bsdf.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = rough
+        <span class="k">return</span> mat
+
+    <span class="c"># designed non-data surfaces: painted steel board, darker rail/frame</span>
+    <span class="c"># steel, dark polymer bezels, machined bolt heads — no Principled</span>
+    <span class="c"># defaults</span>
+    fixture = mat_principled(<span class="s">&quot;FixtureSteel&quot;</span>, (<span class="n">0.11</span>, <span class="n">0.12</span>, <span class="n">0.14</span>), <span class="n">0.25</span>, <span class="n">0.55</span>)
+    rail_mat = mat_principled(<span class="s">&quot;RailSteel&quot;</span>, (<span class="n">0.075</span>, <span class="n">0.08</span>, <span class="n">0.09</span>), <span class="n">0.6</span>, <span class="n">0.45</span>)
+    bezel_mat = mat_principled(<span class="s">&quot;BezelPolymer&quot;</span>, (<span class="n">0.045</span>, <span class="n">0.048</span>, <span class="n">0.055</span>), <span class="n">0.0</span>, <span class="n">0.5</span>)
+    hot_mat = mat_principled(<span class="s">&quot;HotFrame&quot;</span>, (<span class="n">0.80</span>, <span class="n">0.28</span>, <span class="n">0.06</span>), <span class="n">0.1</span>, <span class="n">0.5</span>)
+    bolt_mat = mat_principled(<span class="s">&quot;BoltSteel&quot;</span>, (<span class="n">0.22</span>, <span class="n">0.23</span>, <span class="n">0.26</span>), <span class="n">0.9</span>, <span class="n">0.5</span>)
+    plinth_mat = mat_principled(<span class="s">&quot;PlinthSteel&quot;</span>, (<span class="n">0.10</span>, <span class="n">0.11</span>, <span class="n">0.12</span>), <span class="n">0.6</span>, <span class="n">0.5</span>)
+
+    <span class="k">def</span> box(name, dims, loc, mat, rot_x=<span class="n">0.0</span>):
         me = bpy.data.meshes.new(name)
         bm = bmesh.new()
         <span class="k">try</span>:
             bmesh.ops.create_cube(bm, size=<span class="n">1.0</span>,
-                                  matrix=mathutils.Matrix.Diagonal(
-                                      (<span class="n">1.5</span>, <span class="n">0.12</span>, <span class="n">1.65</span>, <span class="n">1.0</span>)))
+                                  matrix=mathutils.Matrix.Diagonal((*dims, <span class="n">1.0</span>)))
             bm.to_mesh(me)
         <span class="k">finally</span>:
             bm.free()
         me.materials.append(mat)
         ob = bpy.data.objects.new(name, me)
-        ob.location = (x, y, z)
+        ob.location = loc
+        ob.rotation_euler = (rot_x, <span class="n">0.0</span>, <span class="n">0.0</span>)
+        sc.collection.objects.link(ob)
+
+    <span class="k">def</span> bolt(x, z):
+        me = bpy.data.meshes.new(<span class="s">&quot;Bolt&quot;</span>)
+        bm = bmesh.new()
+        <span class="k">try</span>:
+            bmesh.ops.create_cone(bm, cap_ends=<span class="k">True</span>, cap_tris=<span class="k">False</span>,
+                                  segments=<span class="n">6</span>, radius1=<span class="n">0.085</span>, radius2=<span class="n">0.085</span>,
+                                  depth=<span class="n">0.07</span>)
+            bm.to_mesh(me)
+        <span class="k">finally</span>:
+            bm.free()
+        me.materials.append(bolt_mat)
+        ob = bpy.data.objects.new(<span class="s">&quot;Bolt&quot;</span>, me)
+        ob.location = (x, -<span class="n">0.035</span>, z)
+        ob.rotation_euler = (m.radians(<span class="n">90</span>), <span class="n">0.0</span>, <span class="n">0.0</span>)
         sc.collection.objects.link(ob)
-        <span class="k">if</span> hot:
-            <span class="c"># hazard-orange backplate on the impostor: a broken (naive)</span>
-            <span class="c"># cross would make the framed swatch match its neighbor</span>
-            frame_mat = bpy.data.materials.new(<span class="s">&quot;HotFrame&quot;</span>)
-            frame_mat.use_nodes = <span class="k">True</span>
-            fb = frame_mat.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.80</span>, <span class="n">0.28</span>, <span class="n">0.06</span>, <span class="n">1.0</span>)
-            fb.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.5</span>
-            fm = bpy.data.meshes.new(<span class="s">&quot;Frame&quot;</span>)
-            bm = bmesh.new()
-            <span class="k">try</span>:
-                bmesh.ops.create_cube(bm, size=<span class="n">1.0</span>,
-                                      matrix=mathutils.Matrix.Diagonal(
-                                          (<span class="n">1.64</span>, <span class="n">0.06</span>, <span class="n">1.79</span>, <span class="n">1.0</span>)))
-                bm.to_mesh(fm)
-            <span class="k">finally</span>:
-                bm.free()
-            fm.materials.append(frame_mat)
-            fob = bpy.data.objects.new(<span class="s">&quot;Frame&quot;</span>, fm)
-            fob.location = (x, y + <span class="n">0.075</span>, z)
-            sc.collection.objects.link(fob)
+
+    <span class="k">def</span> swatch(name, rgb):
+        <span class="c"># the data faces stay pure emission: exact values, no specular,</span>
+        <span class="c"># no texture — the image is a data display</span>
+        mat = bpy.data.materials.new(<span class="s">f&quot;</span><span class="s">Swatch</span>{name}<span class="s">&quot;</span>)
+        mat.use_nodes = <span class="k">True</span>
+        nt = mat.node_tree
+        nt.nodes.clear()
+        out = nt.nodes.new(<span class="s">&quot;ShaderNodeOutputMaterial&quot;</span>)
+        em = nt.nodes.new(<span class="s">&quot;ShaderNodeEmission&quot;</span>)
+        em.inputs[<span class="s">&quot;Color&quot;</span>].default_value = (*rgb, <span class="n">1.0</span>)
+        em.inputs[<span class="s">&quot;Strength&quot;</span>].default_value = <span class="n">1.0</span>
+        nt.links.new(em.outputs[<span class="s">&quot;Emission&quot;</span>], out.inputs[<span class="s">&quot;Surface&quot;</span>])
+        <span class="k">return</span> mat
+
+    <span class="k">def</span> chip(name, rgb, x, z, size, hot=<span class="k">False</span>):
+        <span class="c"># glowing chip seated proud of its bezel; the naive impostor keeps</span>
+        <span class="c"># the hazard-orange frame — a broken (naive) cross would make the</span>
+        <span class="c"># framed chip match its neighbor</span>
+        box(<span class="s">f&quot;</span><span class="s">Bezel</span>{name}<span class="s">&quot;</span>, (size + <span class="n">0.20</span>, <span class="n">0.16</span>, size + <span class="n">0.20</span>),
+            (x, -<span class="n">0.08</span>, z), hot_mat <span class="k">if</span> hot <span class="k">else</span> bezel_mat)
+        box(<span class="s">f&quot;</span><span class="s">Chip</span>{name}<span class="s">&quot;</span>, (size, <span class="n">0.12</span>, size), (x, -<span class="n">0.13</span>, z),
+            swatch(name, rgb))
+
+    <span class="c"># the booth: bolted board with cap rails, rear struts down to the plinth</span>
+    box(<span class="s">&quot;Board&quot;</span>, (<span class="n">7.20</span>, <span class="n">0.34</span>, <span class="n">5.00</span>), (<span class="n">0.0</span>, <span class="n">0.17</span>, <span class="n">3.50</span>), fixture)
+    box(<span class="s">&quot;RailTop&quot;</span>, (<span class="n">7.34</span>, <span class="n">0.42</span>, <span class="n">0.16</span>), (<span class="n">0.0</span>, <span class="n">0.17</span>, <span class="n">6.06</span>), rail_mat)
+    box(<span class="s">&quot;RailBottom&quot;</span>, (<span class="n">7.34</span>, <span class="n">0.42</span>, <span class="n">0.20</span>), (<span class="n">0.0</span>, <span class="n">0.17</span>, <span class="n">0.94</span>), rail_mat)
+    <span class="c"># panel seam between the fade row and the contrast pair</span>
+    box(<span class="s">&quot;Seam&quot;</span>, (<span class="n">7.00</span>, <span class="n">0.02</span>, <span class="n">0.035</span>), (<span class="n">0.0</span>, -<span class="n">0.005</span>, <span class="n">3.70</span>), rail_mat)
+    <span class="k">for</span> bx <span class="k">in</span> (-<span class="n">3.36</span>, <span class="n">3.36</span>):
+        <span class="k">for</span> bz <span class="k">in</span> (<span class="n">1.30</span>, <span class="n">5.70</span>):
+            bolt(bx, bz)
+    <span class="k">for</span> sx <span class="k">in</span> (-<span class="n">2.30</span>, <span class="n">2.30</span>):
+        box(<span class="s">&quot;Strut&quot;</span>, (<span class="n">0.30</span>, <span class="n">0.34</span>, <span class="n">2.32</span>), (sx, <span class="n">0.70</span>, <span class="n">1.60</span>), rail_mat,
+            rot_x=m.radians(<span class="n">18</span>))
+        box(<span class="s">&quot;Foot&quot;</span>, (<span class="n">0.50</span>, <span class="n">0.64</span>, <span class="n">0.10</span>), (sx, <span class="n">1.02</span>, <span class="n">0.55</span>), rail_mat)
+    box(<span class="s">&quot;Plinth&quot;</span>, (<span class="n">6.60</span>, <span class="n">2.00</span>, <span class="n">0.50</span>), (<span class="n">0.0</span>, <span class="n">0.35</span>, <span class="n">0.25</span>), plinth_mat)
 
     by_t = {t: f <span class="k">for</span> f, t <span class="k">in</span> SAMPLES}
     <span class="c"># the authentic fade across the top, left to right</span>
     top = [(<span class="n">0.0</span>, <span class="s">&quot;t=0&quot;</span>), (<span class="n">0.25</span>, <span class="s">&quot;t=1/4&quot;</span>), (<span class="n">0.5</span>, <span class="s">&quot;t=1/2&quot;</span>), (<span class="n">0.75</span>, <span class="s">&quot;t=3/4&quot;</span>)]
-    top_xs = [-<span class="n">2.775</span> + <span class="n">1.85</span> * i <span class="k">for</span> i <span class="k">in</span> range(<span class="n">4</span>)]
+    top_xs = [-<span class="n">2.625</span> + <span class="n">1.75</span> * i <span class="k">for</span> i <span class="k">in</span> range(<span class="n">4</span>)]
     <span class="k">for</span> (t, _label), x <span class="k">in</span> zip(top, top_xs):
-        panel(<span class="s">f&quot;</span><span class="s">t</span>{t}<span class="s">&quot;</span>, got[by_t[t]], x, z=<span class="n">3.25</span>)
-    <span class="c"># the contrast pair at frame center: true mid beside the naive mid</span>
-    panel(<span class="s">&quot;true_mid&quot;</span>, got[by_t[<span class="n">0.5</span>]], -<span class="n">0.80</span>, z=<span class="n">1.40</span>, y=-<span class="n">0.30</span>)
-    panel(<span class="s">&quot;naive_mid&quot;</span>, tuple(naive(<span class="n">0.5</span>, k) <span class="k">for</span> k <span class="k">in</span> range(<span class="n">3</span>)),
-          <span class="n">0.80</span>, z=<span class="n">1.40</span>, y=-<span class="n">0.30</span>, hot=<span class="k">True</span>)
-
-    <span class="c"># captions: t-labels crown the fade row; the pair is named on the</span>
-    <span class="c"># plinth face, facing the camera (a floor caption foreshortens away)</span>
+        chip(<span class="s">f&quot;</span><span class="s">t</span>{t}<span class="s">&quot;</span>, got[by_t[t]], x, z=<span class="n">4.72</span>, size=<span class="n">1.32</span>)
+    <span class="c"># the contrast pair at center: true mid beside the naive mid</span>
+    chip(<span class="s">&quot;true_mid&quot;</span>, got[by_t[<span class="n">0.5</span>]], -<span class="n">1.05</span>, z=<span class="n">2.55</span>, size=<span class="n">1.55</span>)
+    chip(<span class="s">&quot;naive_mid&quot;</span>, tuple(naive(<span class="n">0.5</span>, k) <span class="k">for</span> k <span class="k">in</span> range(<span class="n">3</span>)),
+         <span class="n">1.05</span>, z=<span class="n">2.55</span>, size=<span class="n">1.55</span>, hot=<span class="k">True</span>)
+
+    <span class="c"># captions: t-labels crown the fade chips; the pair is named beneath it</span>
     cu_mat = bpy.data.materials.new(<span class="s">&quot;CaptionGrey&quot;</span>)
     cu_mat.use_nodes = <span class="k">True</span>
     cb = cu_mat.node_tree.nodes[<span class="s">&quot;Principled BSDF&quot;</span>]
@@ -467,9 +512,9 @@ <h2>Source</h2>
     cb.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.6</span>
     sock = cb.inputs.get(<span class="s">&quot;Emission Color&quot;</span>) <span class="k">or</span> cb.inputs[<span class="s">&quot;Emission&quot;</span>]
     sock.default_value = (<span class="n">0.38</span>, <span class="n">0.40</span>, <span class="n">0.45</span>, <span class="n">1.0</span>)
-    cb.inputs[<span class="s">&quot;Emission Strength&quot;</span>].default_value = <span class="n">0.45</span>
+    cb.inputs[<span class="s">&quot;Emission Strength&quot;</span>].default_value = <span class="n">0.5</span>
 
-    <span class="k">def</span> caption(text, x, z, y=-<span class="n">0.09</span>, size=<span class="n">0.16</span>):
+    <span class="k">def</span> caption(text, x, z, size, y=-<span class="n">0.03</span>):
         cu = bpy.data.curves.new(<span class="s">&quot;Caption&quot;</span>, <span class="s">&#x27;FONT&#x27;</span>)
         cu.body = text
         cu.align_x = <span class="s">&#x27;CENTER&#x27;</span>
@@ -482,9 +527,9 @@ <h2>Source</h2>
         sc.collection.objects.link(ob)
 
     <span class="k">for</span> (_t, label), x <span class="k">in</span> zip(top, top_xs):
-        caption(label, x, <span class="n">4.22</span>)
-    caption(<span class="s">&quot;GAMMA_CROSS t=1/2&quot;</span>, -<span class="n">0.80</span>, <span class="n">0.23</span>, y=-<span class="n">0.46</span>, size=<span class="n">0.15</span>)
-    caption(<span class="s">&quot;NAIVE LERP t=1/2&quot;</span>, <span class="n">0.80</span>, <span class="n">0.23</span>, y=-<span class="n">0.46</span>, size=<span class="n">0.15</span>)
+        caption(label, x, <span class="n">5.62</span>, <span class="n">0.20</span>)
+    caption(<span class="s">&quot;GAMMA_CROSS t=1/2&quot;</span>, -<span class="n">1.05</span>, <span class="n">1.42</span>, <span class="n">0.20</span>)
+    caption(<span class="s">&quot;NAIVE LERP t=1/2&quot;</span>, <span class="n">1.05</span>, <span class="n">1.42</span>, <span class="n">0.20</span>)
 
 
 <span class="k">def</span> render_still(sc, got, path, engine):
@@ -492,26 +537,6 @@ <h2>Source</h2>
     build_bench(scene, got)
 
     <span class="k">import</span> mathutils, bmesh
-    <span class="c"># a low plinth shelf grounds the bench without eating the frame</span>
-    plinth_me = bpy.data.meshes.new(<span class="s">&quot;Plinth&quot;</span>)
-    bm2 = bmesh.new()
-    <span class="k">try</span>:
-        bmesh.ops.create_cube(bm2, size=<span class="n">1.0</span>,
-                              matrix=mathutils.Matrix.Diagonal((<span class="n">6.9</span>, <span class="n">1.3</span>, <span class="n">0.45</span>, <span class="n">1.0</span>)))
-        bm2.to_mesh(plinth_me)
-    <span class="k">finally</span>:
-        bm2.free()
-    cmat = bpy.data.materials.new(<span class="s">&quot;ConsoleMetal&quot;</span>)
-    cmat.use_nodes = <span class="k">True</span>
-    cc = cmat.node_tree.nodes[<span class="s">&quot;Principled BSDF&quot;</span>]
-    cc.inputs[<span class="s">&quot;Base Color&quot;</span>].default_value = (<span class="n">0.07</span>, <span class="n">0.08</span>, <span class="n">0.09</span>, <span class="n">1.0</span>)
-    cc.inputs[<span class="s">&quot;Metallic&quot;</span>].default_value = <span class="n">0.7</span>
-    cc.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.5</span>
-    plinth_me.materials.append(cmat)
-    plinth = bpy.data.objects.new(<span class="s">&quot;Plinth&quot;</span>, plinth_me)
-    plinth.location = (<span class="n">0.0</span>, <span class="n">0.2</span>, <span class="n">0.225</span>)
-    scene.collection.objects.link(plinth)
-
     floor_me = bpy.data.meshes.new(<span class="s">&quot;Floor&quot;</span>)
     bm = bmesh.new()
     <span class="k">try</span>:
@@ -547,20 +572,21 @@ <h2>Source</h2>
         scene.collection.objects.link(ob)
 
     <span class="c"># shaped warm key, faint cool fill, cool rim, and the signature warm</span>
-    <span class="c"># wedge between bench and wall raking a pool onto the backdrop — the</span>
+    <span class="c"># wedge between booth and wall raking a pool onto the backdrop — the</span>
     <span class="c"># wall itself stays near-black outside the pool (docs/VISUAL-STYLE.md)</span>
-    light(<span class="s">&quot;Key&quot;</span>, (-<span class="n">4.0</span>, -<span class="n">4.0</span>, <span class="n">6.5</span>), <span class="n">420.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>), (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">1.8</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">80.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">0.5</span>, <span class="n">0.0</span>, <span class="n">1.6</span>))
-    light(<span class="s">&quot;Rim&quot;</span>, (<span class="n">0.5</span>, <span class="n">4.0</span>, <span class="n">6.0</span>), <span class="n">260.0</span>, <span class="n">4.0</span>, (<span class="n">0.6</span>, <span class="n">0.78</span>, <span class="n">1.0</span>), (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">2.6</span>))
-    light(<span class="s">&quot;Wedge&quot;</span>, (<span class="n">1.2</span>, <span class="n">5.0</span>, <span class="n">4.5</span>), <span class="n">340.0</span>, <span class="n">5.0</span>, (<span class="n">1.0</span>, <span class="n">0.76</span>, <span class="n">0.5</span>), (-<span class="n">0.2</span>, <span class="n">9.0</span>, <span class="n">1.2</span>))
+    light(<span class="s">&quot;Key&quot;</span>, (-<span class="n">4.0</span>, -<span class="n">4.5</span>, <span class="n">7.0</span>), <span class="n">460.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">0.0</span>, <span class="n">0.2</span>, <span class="n">3.0</span>))
+    light(<span class="s">&quot;Fill&quot;</span>, (<span class="n">6.0</span>, -<span class="n">3.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">0.5</span>, <span class="n">0.0</span>, <span class="n">2.8</span>))
+    light(<span class="s">&quot;Rim&quot;</span>, (<span class="n">0.5</span>, <span class="n">4.5</span>, <span class="n">7.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">0.0</span>, <span class="n">0.3</span>, <span class="n">4.2</span>))
+    light(<span class="s">&quot;Wedge&quot;</span>, (<span class="n">0.5</span>, <span class="n">5.5</span>, <span class="n">6.0</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">0.5</span>, <span class="n">9.0</span>, <span class="n">4.2</span>))
 
+    <span class="c"># 3/4 angle from the right: the booth shows face, side, and cast shadow</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">0.7</span>, -<span class="n">13.0</span>, <span class="n">3.4</span>)
+    cam.location = (<span class="n">9.7</span>, -<span class="n">17.5</span>, <span class="n">5.7</span>)
     scene.collection.objects.link(cam)
     target = bpy.data.objects.new(<span class="s">&quot;Aim&quot;</span>, <span class="k">None</span>)
-    target.location = (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">2.15</span>)
+    target.location = (<span class="n">0.0</span>, <span class="n">0.2</span>, <span class="n">3.2</span>)
     scene.collection.objects.link(target)
     con = cam.constraints.new(<span class="s">&#x27;TRACK_TO&#x27;</span>)
     con.target = target
diff --git a/examples/gallery.json b/examples/gallery.json
index 1fde9ef..69b4afc 100644
--- a/examples/gallery.json
+++ b/examples/gallery.json
@@ -361,8 +361,8 @@
     {
       "name": "light-link-studio",
       "dir": "examples/light-link-studio",
-      "teaches": "One key, one hero: a light linked to a receiver collection lights only the hero, proven by two pixel renders in one pass. Linked: 3.6x luminance ratio; unlinked in the same check: the decoy rises 206% while the hero holds at 0.0% drift.",
-      "witnessesFix": "The API is obj.light_linking on the light OBJECT (ld.light_linking is an AttributeError). Luminance is sampled at each sphere's projected center; EEVEE honors linking too (probe-measured 3.7x on 4.5.11 EEVEE Next and 5.1.2 EEVEE), Cycles pinned for deterministic samples.",
+      "teaches": "One key, one hero: a light linked to a receiver collection lights only the hero, proven by two pixel renders in one pass. Linked: 3.6x luminance ratio; unlinked in the same check: the decoy rises 233% while the hero holds at 0.3% drift.",
+      "witnessesFix": "The API is obj.light_linking on the light OBJECT (ld.light_linking is an AttributeError). Luminance is sampled at each sphere's projected center; EEVEE honors linking too (probe-measured 3.8x on 4.5.11 EEVEE Next and 5.1.2 EEVEE), Cycles pinned for deterministic samples.",
       "hero": "docs/gallery/assets/light-link-studio-hero.webp",
       "preview": "examples/light-link-studio/preview.webp",
       "tags": [
diff --git a/examples/light-link-studio/README.md b/examples/light-link-studio/README.md
index dbbe8c1..0648d38 100644
--- a/examples/light-link-studio/README.md
+++ b/examples/light-link-studio/README.md
@@ -16,7 +16,7 @@ most often misses or misaddresses.
   **3.6x** (gate ≥ 3x), measured at each sphere's **projected** center so
   framing can't move the sample off the subject.
 - **Unlinked (same check), the restriction vanishes surgically.** Render
-  two: the decoy rises **206–213%** while the hero drifts **0.0%** — the
+  two: the decoy rises **233–238%** while the hero drifts **0.1–0.3%** — the
   link restricts without dimming anything else. The shipped check therefore
   demonstrates both states, not just one. The rise figure is noisy by
   construction: the decoy's unlit base sits near the fill floor, so small
@@ -25,7 +25,7 @@ most often misses or misaddresses.
 - **The engine note, verified rather than assumed.** Light linking also
   works on EEVEE — measured with an EEVEE luminance probe (the shipped
   scene with `render.engine` swapped: `BLENDER_EEVEE` on 5.x,
-  `BLENDER_EEVEE_NEXT` on 4.x) at **3.7x** linked ratio on both 4.5.11
+  `BLENDER_EEVEE_NEXT` on 4.x) at **3.8x** linked ratio on both 4.5.11
   EEVEE Next and 5.1.2 EEVEE, matching Cycles within sampling noise. The
   shipped check still pins Cycles for deterministic tiny-sample CPU
   renders; luminance gates need `view_transform = 'Standard'` (AgX
@@ -38,12 +38,14 @@ assignment read-back (exit 5), a link that doesn't restrict (exit 7, rise
 below 50%), and a non-surgical restriction (exit 8, hero drift above 5%).
 
 **Version witness:** ObjectLightLinking API and the measured ratios match on
-Blender 4.5 LTS and 5.1 (3.4x vs 3.6x linked; rise 213% vs 206% — inside the
+Blender 4.5 LTS and 5.1 (3.7x vs 3.6x linked; rise 238% vs 233% — inside the
 rise noise described above).
 
-The render is the contract at a glance: the blazing orange hero over the
-LINKED plaque, the cold steel decoy over UNLINKED, a warm pool raking the
-wall behind them — one key, one hero.
+The render is the contract at a glance: the spheres staged as studio
+specimens on matching turned-metal pedestals — the blazing orange hero over
+its LINKED placard with the warm floor inlay marking the linked light's
+footprint, the cold steel decoy over UNLINKED with its inlay dark, a warm
+pool raking the wall behind them — one key, one hero.
 
 ## Run
 
diff --git a/examples/light-link-studio/light_link_studio.py b/examples/light-link-studio/light_link_studio.py
index b5a1d0c..9e82368 100644
--- a/examples/light-link-studio/light_link_studio.py
+++ b/examples/light-link-studio/light_link_studio.py
@@ -14,7 +14,7 @@
 The engine note, verified rather than assumed: light linking also works on
 EEVEE — measured with an EEVEE luminance probe (this scene, only
 ``render.engine`` swapped: ``BLENDER_EEVEE`` on 5.x, ``BLENDER_EEVEE_NEXT``
-on 4.x) at 3.7x linked ratio on both 4.5.11 EEVEE Next and 5.1.2 EEVEE,
+on 4.x) at 3.8x linked ratio on both 4.5.11 EEVEE Next and 5.1.2 EEVEE,
 matching Cycles within sampling noise. The shipped check pins Cycles for
 deterministic tiny-sample CPU renders. The API is stable between Blender
 4.5 LTS and 5.1 (ObjectLightLinking with
@@ -27,11 +27,13 @@
     blender --background --python light_link_studio.py -- --output l.png  # + render
 """
 import bpy, bmesh, sys, os, math, argparse, tempfile, shutil
+from mathutils import Matrix
 
 HERO_RGB = (0.85, 0.30, 0.08)     # hazard orange
 DECOY_RGB = (0.30, 0.34, 0.40)    # cold steel
 KEY_ENERGY = 560.0
 FILL_ENERGY = 26.0
+SPHERE_Z = 1.18                   # center: sphere rests on the pedestal cap
 PXW, PXH = 64, 36
 RATIO_MIN = 3.0                   # hero/decoy luminance ratio, linked
 HERO_LUMA_MIN = 0.25              # hero must be well-lit, linked
@@ -56,11 +58,90 @@ def sphere(name, rgb, x, coll):
     b.inputs["Roughness"].default_value = 0.55
     me.materials.append(mat)
     ob = bpy.data.objects.new(name, me)
-    ob.location = (x, 0.0, 0.55)
+    ob.location = (x, 0.0, SPHERE_Z)
     coll.objects.link(ob)
     return ob
 
 
+def _principled(name, rgb, rough, metallic=0.0, emit=None, estr=0.0):
+    mat = bpy.data.materials.new(name)
+    mat.use_nodes = True
+    b = mat.node_tree.nodes["Principled BSDF"]
+    b.inputs["Base Color"].default_value = (*rgb, 1.0)
+    b.inputs["Roughness"].default_value = rough
+    b.inputs["Metallic"].default_value = metallic
+    if emit is not None:
+        sock = b.inputs.get("Emission Color") or b.inputs["Emission"]
+        sock.default_value = (*emit, 1.0)
+        b.inputs["Emission Strength"].default_value = estr
+    return mat
+
+
+def _bevel(ob, width, segments=2):
+    mod = ob.modifiers.new("Bev", 'BEVEL')
+    mod.width = width
+    mod.segments = segments
+    mod.limit_method = 'ANGLE'
+
+
+def _cyl(sc, name, r1, r2, depth, loc, mat, bevel=0.0):
+    me = bpy.data.meshes.new(name)
+    bm = bmesh.new()
+    try:
+        bmesh.ops.create_cone(bm, cap_ends=True, cap_tris=False,
+                              segments=48, radius1=r1, radius2=r2, depth=depth)
+        bm.to_mesh(me)
+    finally:
+        bm.free()
+    me.update()
+    for p in me.polygons:       # smooth the wall, keep the caps flat
+        p.use_smooth = abs(p.normal.z) < 0.5
+    me.materials.append(mat)
+    ob = bpy.data.objects.new(name, me)
+    ob.location = loc
+    sc.collection.objects.link(ob)
+    if bevel:
+        _bevel(ob, bevel)
+    return ob
+
+
+def _box(sc, name, dims, loc, mat, bevel=0.0, parent=None):
+    me = bpy.data.meshes.new(name)
+    bm = bmesh.new()
+    try:
+        bmesh.ops.create_cube(bm, size=1.0)
+        bmesh.ops.transform(bm, matrix=Matrix.Diagonal((*dims, 1.0)),
+                            verts=bm.verts)
+        bm.to_mesh(me)
+    finally:
+        bm.free()
+    me.materials.append(mat)
+    ob = bpy.data.objects.new(name, me)
+    ob.location = loc
+    if parent is not None:
+        ob.parent = parent
+    sc.collection.objects.link(ob)
+    if bevel:
+        _bevel(ob, bevel, segments=3)
+    return ob
+
+
+def pedestal(sc, x, dark, metal):
+    """A designed specimen plinth: turned foot, dark polymer body with a
+    flat front for the placard, machined collar band, round cap."""
+    _cyl(sc, "PedFoot", 0.58, 0.54, 0.09, (x, 0.0, 0.045), metal, 0.02)
+    _box(sc, "PedBody", (0.74, 0.54, 0.50), (x, 0.0, 0.34), dark, 0.05)
+    _box(sc, "PedCollar", (0.80, 0.60, 0.05), (x, 0.0, 0.615), metal, 0.015)
+    _cyl(sc, "PedCap", 0.42, 0.42, 0.06, (x, 0.0, 0.67), metal, 0.02)
+
+
+def floor_inlay(sc, x, mat):
+    """Thin disc flush with the floor: the linked light's footprint. The
+    hero's is emissive warm; the decoy's is dark metal — a footprint that
+    never lights, and therefore cannot pollute the decoy's fill floor."""
+    _cyl(sc, "Inlay", 0.74, 0.74, 0.014, (x, 0.0, 0.007), mat)
+
+
 def add_light(sc, name, energy, loc, color, size, aim=None, rot=None):
     ld = bpy.data.lights.new(name, 'AREA')
     ld.energy = energy
@@ -80,7 +161,9 @@ def add_light(sc, name, energy, loc, color, size, aim=None, rot=None):
 
 
 def build_studio(sc):
-    """Hero and decoy on one stage, plus a low fill that lights both."""
+    """Hero and decoy as specimens on plinths, plus a low fill that lights
+    both. The plinths and inlays are dressing only: the witness is still two
+    identical spheres where one key reaches only the hero."""
     hero_c = bpy.data.collections.new("HeroColl")
     decoy_c = bpy.data.collections.new("DecoyColl")
     hero = sphere("Hero", HERO_RGB, -1.2, hero_c)
@@ -88,6 +171,17 @@ def build_studio(sc):
     sc.collection.children.link(hero_c)
     sc.collection.children.link(decoy_c)
 
+    ped_dark = _principled("PedDark", (0.05, 0.052, 0.06), 0.5, metallic=0.15)
+    ped_metal = _principled("PedMetal", (0.16, 0.17, 0.20), 0.3, metallic=0.9)
+    pedestal(sc, -1.2, ped_dark, ped_metal)
+    pedestal(sc, 1.2, ped_dark, ped_metal)
+    inlay_warm = _principled("InlayWarm", (0.02, 0.018, 0.016), 0.6,
+                             emit=(0.85, 0.36, 0.09), estr=1.1)
+    inlay_dark = _principled("InlayDark", (0.07, 0.075, 0.085), 0.35,
+                             metallic=0.85)
+    floor_inlay(sc, -1.2, inlay_warm)
+    floor_inlay(sc, 1.2, inlay_dark)
+
     floor_me = bpy.data.meshes.new("Floor")
     bm = bmesh.new()
     try:
@@ -133,9 +227,16 @@ def build_studio(sc):
     cam = bpy.data.cameras.new("Cam")
     cam.lens = 50.0
     cam_ob = bpy.data.objects.new("Cam", cam)
-    cam_ob.location = (0.0, -6.2, 2.0)
+    cam_ob.location = (0.0, -6.2, 2.3)
+    # the camera frames the raised specimens, the lights keep their own aim —
+    # re-aiming the lights would move the measured luminance. The steeper
+    # down-angle also keeps the decoy's fill-floor luminance at its measured
+    # baseline — a flatter camera samples a brighter point on the decoy.
+    cam_aim = bpy.data.objects.new("CamAim", None)
+    cam_aim.location = (0.0, 0.0, 0.8)
+    sc.collection.objects.link(cam_aim)
     con = cam_ob.constraints.new('TRACK_TO')
-    con.target = aim
+    con.target = cam_aim
     con.track_axis = 'TRACK_NEGATIVE_Z'
     con.up_axis = 'UP_Y'
     sc.collection.objects.link(cam_ob)
@@ -245,33 +346,39 @@ def check(sc, key, hero_c, hero, decoy):
     return 0
 
 
-def plaque(sc, text, x):
-    pm = bpy.data.materials.new("PlaqueMetal")
-    pm.use_nodes = True
-    pb = pm.node_tree.nodes["Principled BSDF"]
-    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
-    # faint self-glow: the UNLINKED plaque must read even in the decoy's dark
-    sock = pb.inputs.get("Emission Color") or pb.inputs["Emission"]
-    sock.default_value = (0.35, 0.37, 0.42, 1.0)
-    pb.inputs["Emission Strength"].default_value = 0.6
-    cu = bpy.data.curves.new("Plaque", 'FONT')
+def placard(sc, text, x, plate_m, stand_m, text_m):
+    """Museum nameplate: a beveled plate on two standoffs bolted to the
+    plinth front, tilted back to face the raised camera, text on its face."""
+    root = bpy.data.objects.new("Placard", None)
+    root.location = (x, -0.325, 0.34)
+    root.rotation_euler = (math.radians(71), 0.0, 0.0)
+    sc.collection.objects.link(root)
+    _box(sc, "Plate", (0.92, 0.22, 0.024), (0.0, 0.0, 0.0), plate_m,
+         0.012, parent=root)
+    for sx in (-0.30, 0.30):
+        _cyl(sc, "Standoff", 0.016, 0.016, 0.055, (sx, 0.0, -0.038),
+             stand_m).parent = root
+    cu = bpy.data.curves.new("PlacardText", 'FONT')
     cu.body = text
     cu.align_x = 'CENTER'
-    cu.size = 0.22
-    cu.extrude = 0.006
-    ob = bpy.data.objects.new("Plaque", cu)
-    # standing upright on the floor, tilted back to face the raised camera
-    ob.location = (x, -1.3, 0.17)
-    ob.rotation_euler = (math.radians(76), 0.0, 0.0)
-    ob.data.materials.append(pm)
+    cu.align_y = 'CENTER'
+    cu.size = 0.15
+    cu.extrude = 0.004
+    ob = bpy.data.objects.new("PlacardText", cu)
+    ob.location = (0.0, 0.0, 0.0165)
+    ob.parent = root
+    cu.materials.append(text_m)
     sc.collection.objects.link(ob)
 
 
 def render_still(sc, path):
-    plaque(sc, "LINKED", -1.2)
-    plaque(sc, "UNLINKED", 1.2)
+    plate_m = _principled("PlateBlack", (0.03, 0.032, 0.038), 0.6)
+    stand_m = _principled("StandMetal", (0.16, 0.17, 0.20), 0.3, metallic=0.9)
+    # faint self-glow: the UNLINKED placard must read even in the decoy's dark
+    text_m = _principled("PlacardText", (0.42, 0.44, 0.48), 0.6, metallic=0.2,
+                         emit=(0.35, 0.37, 0.42), estr=0.6)
+    placard(sc, "LINKED", -1.2, plate_m, stand_m, text_m)
+    placard(sc, "UNLINKED", 1.2, plate_m, stand_m, text_m)
     # the gallery still is the linked state, on Cycles for the same
     # deterministic sampling as the check
     sc.render.engine = 'CYCLES'
diff --git a/examples/light-link-studio/preview.webp b/examples/light-link-studio/preview.webp
index ff6961c..9b8d8db 100644
Binary files a/examples/light-link-studio/preview.webp and b/examples/light-link-studio/preview.webp differ
diff --git a/examples/vse-gamma-cross/README.md b/examples/vse-gamma-cross/README.md
index e83fe4c..17c4fd7 100644
--- a/examples/vse-gamma-cross/README.md
+++ b/examples/vse-gamma-cross/README.md
@@ -37,12 +37,14 @@ every sample matches to the quantization step. The creation contract from
 `vse-cut-list` still gates the timeline: `strips` (never `.sequences`), and
 `new_effect` ending in `length=` on 5.x vs `frame_end=` on 4.5.
 
-The render is the bench: the authentic fade as four large emissive panels
-(t = 0, 1/4, 1/2, 3/4) above the contrast pair at frame center — the true mid
-swatch directly beside the naive lerp mid, the impostor framed in hazard
-orange. The gamma dip reads as an adjacency contrast even at card scale: a
-naive-lerp cross would make the pair identical, so the still visibly breaks
-with the contract.
+The render is a calibration lightbox: the authentic fade as four backlit
+chips (t = 0, 1/4, 1/2, 3/4) set into bezels on a bolted steel swatch board
+— cap rails, panel seam, corner bolts, rear struts down to a plinth — shot
+at a 3/4 angle so it reads as a staged object. Below the fade row sits the
+contrast pair: the true mid chip directly beside the naive lerp mid, the
+impostor framed in hazard orange. The gamma dip reads as an adjacency
+contrast even at card scale: a naive-lerp cross would make the pair
+identical, so the still visibly breaks with the contract.
 
 ## Run
 
@@ -50,7 +52,7 @@ with the contract.
 # Correctness check (tiny per-frame sample renders) — the CI check:
 blender --background --python vse_gamma_cross.py --
 
-# Also render the mixing bench still (EEVEE on a GPU host; cycles on GPU-less):
+# Also render the calibration lightbox still (EEVEE on a GPU host; cycles on GPU-less):
 blender --background --python vse_gamma_cross.py -- --output bench.png
 blender --background --python vse_gamma_cross.py -- --output bench.png --engine cycles
 ```
diff --git a/examples/vse-gamma-cross/preview.webp b/examples/vse-gamma-cross/preview.webp
index 4f55e49..b6bc58b 100644
Binary files a/examples/vse-gamma-cross/preview.webp and b/examples/vse-gamma-cross/preview.webp differ
diff --git a/examples/vse-gamma-cross/vse_gamma_cross.py b/examples/vse-gamma-cross/vse_gamma_cross.py
index 79153fd..3330b8f 100644
--- a/examples/vse-gamma-cross/vse_gamma_cross.py
+++ b/examples/vse-gamma-cross/vse_gamma_cross.py
@@ -185,74 +185,119 @@ def eevee_engine_id():
 
 
 def build_bench(sc, got):
-    """The mixing bench: the authentic fade as four large emissive panels
-    (t = 0, 1/4, 1/2, 3/4) above the contrast pair — the true mid swatch
-    directly beside the naive lerp mid at frame center, so the gamma dip
-    reads as an adjacency contrast even at card scale. A naive-lerp cross
-    would make the pair identical: the render visibly breaks with the
-    contract."""
+    """The calibration lightbox: a swatch-booth fixture — glowing chips
+    seated in bezels on a bolted steel board, held by rear struts over a
+    plinth — shot at a 3/4 angle so it reads as a staged object, not a
+    flat test chart. The authentic fade runs as four backlit chips across
+    the top (t = 0, 1/4, 1/2, 3/4); the contrast pair is the centerpiece
+    below: the true mid directly beside the naive lerp mid in its
+    hazard-orange bezel, so the gamma dip reads as an adjacency contrast
+    even at card scale. A naive-lerp cross would make the pair identical:
+    the render visibly breaks with the contract."""
     import bmesh
     import mathutils
     import math as m
 
-    def panel(name, rgb, x, z, y=0.0, hot=False):
-        mat = bpy.data.materials.new(f"Swatch{name}")
+    def mat_principled(name, color, metallic, rough):
+        mat = bpy.data.materials.new(name)
         mat.use_nodes = True
-        nt = mat.node_tree
-        nt.nodes.clear()
-        out = nt.nodes.new("ShaderNodeOutputMaterial")
-        em = nt.nodes.new("ShaderNodeEmission")
-        em.inputs["Color"].default_value = (*rgb, 1.0)
-        em.inputs["Strength"].default_value = 1.0
-        nt.links.new(em.outputs["Emission"], out.inputs["Surface"])
+        bsdf = mat.node_tree.nodes["Principled BSDF"]
+        bsdf.inputs["Base Color"].default_value = (*color, 1.0)
+        bsdf.inputs["Metallic"].default_value = metallic
+        bsdf.inputs["Roughness"].default_value = rough
+        return mat
+
+    # designed non-data surfaces: painted steel board, darker rail/frame
+    # steel, dark polymer bezels, machined bolt heads — no Principled
+    # defaults
+    fixture = mat_principled("FixtureSteel", (0.11, 0.12, 0.14), 0.25, 0.55)
+    rail_mat = mat_principled("RailSteel", (0.075, 0.08, 0.09), 0.6, 0.45)
+    bezel_mat = mat_principled("BezelPolymer", (0.045, 0.048, 0.055), 0.0, 0.5)
+    hot_mat = mat_principled("HotFrame", (0.80, 0.28, 0.06), 0.1, 0.5)
+    bolt_mat = mat_principled("BoltSteel", (0.22, 0.23, 0.26), 0.9, 0.5)
+    plinth_mat = mat_principled("PlinthSteel", (0.10, 0.11, 0.12), 0.6, 0.5)
+
+    def box(name, dims, loc, mat, rot_x=0.0):
         me = bpy.data.meshes.new(name)
         bm = bmesh.new()
         try:
             bmesh.ops.create_cube(bm, size=1.0,
-                                  matrix=mathutils.Matrix.Diagonal(
-                                      (1.5, 0.12, 1.65, 1.0)))
+                                  matrix=mathutils.Matrix.Diagonal((*dims, 1.0)))
             bm.to_mesh(me)
         finally:
             bm.free()
         me.materials.append(mat)
         ob = bpy.data.objects.new(name, me)
-        ob.location = (x, y, z)
+        ob.location = loc
+        ob.rotation_euler = (rot_x, 0.0, 0.0)
+        sc.collection.objects.link(ob)
+
+    def bolt(x, z):
+        me = bpy.data.meshes.new("Bolt")
+        bm = bmesh.new()
+        try:
+            bmesh.ops.create_cone(bm, cap_ends=True, cap_tris=False,
+                                  segments=6, radius1=0.085, radius2=0.085,
+                                  depth=0.07)
+            bm.to_mesh(me)
+        finally:
+            bm.free()
+        me.materials.append(bolt_mat)
+        ob = bpy.data.objects.new("Bolt", me)
+        ob.location = (x, -0.035, z)
+        ob.rotation_euler = (m.radians(90), 0.0, 0.0)
         sc.collection.objects.link(ob)
-        if hot:
-            # hazard-orange backplate on the impostor: a broken (naive)
-            # cross would make the framed swatch match its neighbor
-            frame_mat = bpy.data.materials.new("HotFrame")
-            frame_mat.use_nodes = True
-            fb = frame_mat.node_tree.nodes["Principled BSDF"]
-            fb.inputs["Base Color"].default_value = (0.80, 0.28, 0.06, 1.0)
-            fb.inputs["Roughness"].default_value = 0.5
-            fm = bpy.data.meshes.new("Frame")
-            bm = bmesh.new()
-            try:
-                bmesh.ops.create_cube(bm, size=1.0,
-                                      matrix=mathutils.Matrix.Diagonal(
-                                          (1.64, 0.06, 1.79, 1.0)))
-                bm.to_mesh(fm)
-            finally:
-                bm.free()
-            fm.materials.append(frame_mat)
-            fob = bpy.data.objects.new("Frame", fm)
-            fob.location = (x, y + 0.075, z)
-            sc.collection.objects.link(fob)
+
+    def swatch(name, rgb):
+        # the data faces stay pure emission: exact values, no specular,
+        # no texture — the image is a data display
+        mat = bpy.data.materials.new(f"Swatch{name}")
+        mat.use_nodes = True
+        nt = mat.node_tree
+        nt.nodes.clear()
+        out = nt.nodes.new("ShaderNodeOutputMaterial")
+        em = nt.nodes.new("ShaderNodeEmission")
+        em.inputs["Color"].default_value = (*rgb, 1.0)
+        em.inputs["Strength"].default_value = 1.0
+        nt.links.new(em.outputs["Emission"], out.inputs["Surface"])
+        return mat
+
+    def chip(name, rgb, x, z, size, hot=False):
+        # glowing chip seated proud of its bezel; the naive impostor keeps
+        # the hazard-orange frame — a broken (naive) cross would make the
+        # framed chip match its neighbor
+        box(f"Bezel{name}", (size + 0.20, 0.16, size + 0.20),
+            (x, -0.08, z), hot_mat if hot else bezel_mat)
+        box(f"Chip{name}", (size, 0.12, size), (x, -0.13, z),
+            swatch(name, rgb))
+
+    # the booth: bolted board with cap rails, rear struts down to the plinth
+    box("Board", (7.20, 0.34, 5.00), (0.0, 0.17, 3.50), fixture)
+    box("RailTop", (7.34, 0.42, 0.16), (0.0, 0.17, 6.06), rail_mat)
+    box("RailBottom", (7.34, 0.42, 0.20), (0.0, 0.17, 0.94), rail_mat)
+    # panel seam between the fade row and the contrast pair
+    box("Seam", (7.00, 0.02, 0.035), (0.0, -0.005, 3.70), rail_mat)
+    for bx in (-3.36, 3.36):
+        for bz in (1.30, 5.70):
+            bolt(bx, bz)
+    for sx in (-2.30, 2.30):
+        box("Strut", (0.30, 0.34, 2.32), (sx, 0.70, 1.60), rail_mat,
+            rot_x=m.radians(18))
+        box("Foot", (0.50, 0.64, 0.10), (sx, 1.02, 0.55), rail_mat)
+    box("Plinth", (6.60, 2.00, 0.50), (0.0, 0.35, 0.25), plinth_mat)
 
     by_t = {t: f for f, t in SAMPLES}
     # the authentic fade across the top, left to right
     top = [(0.0, "t=0"), (0.25, "t=1/4"), (0.5, "t=1/2"), (0.75, "t=3/4")]
-    top_xs = [-2.775 + 1.85 * i for i in range(4)]
+    top_xs = [-2.625 + 1.75 * i for i in range(4)]
     for (t, _label), x in zip(top, top_xs):
-        panel(f"t{t}", got[by_t[t]], x, z=3.25)
-    # the contrast pair at frame center: true mid beside the naive mid
-    panel("true_mid", got[by_t[0.5]], -0.80, z=1.40, y=-0.30)
-    panel("naive_mid", tuple(naive(0.5, k) for k in range(3)),
-          0.80, z=1.40, y=-0.30, hot=True)
-
-    # captions: t-labels crown the fade row; the pair is named on the
-    # plinth face, facing the camera (a floor caption foreshortens away)
+        chip(f"t{t}", got[by_t[t]], x, z=4.72, size=1.32)
+    # the contrast pair at center: true mid beside the naive mid
+    chip("true_mid", got[by_t[0.5]], -1.05, z=2.55, size=1.55)
+    chip("naive_mid", tuple(naive(0.5, k) for k in range(3)),
+         1.05, z=2.55, size=1.55, hot=True)
+
+    # captions: t-labels crown the fade chips; the pair is named beneath it
     cu_mat = bpy.data.materials.new("CaptionGrey")
     cu_mat.use_nodes = True
     cb = cu_mat.node_tree.nodes["Principled BSDF"]
@@ -261,9 +306,9 @@ def panel(name, rgb, x, z, y=0.0, hot=False):
     cb.inputs["Roughness"].default_value = 0.6
     sock = cb.inputs.get("Emission Color") or cb.inputs["Emission"]
     sock.default_value = (0.38, 0.40, 0.45, 1.0)
-    cb.inputs["Emission Strength"].default_value = 0.45
+    cb.inputs["Emission Strength"].default_value = 0.5
 
-    def caption(text, x, z, y=-0.09, size=0.16):
+    def caption(text, x, z, size, y=-0.03):
         cu = bpy.data.curves.new("Caption", 'FONT')
         cu.body = text
         cu.align_x = 'CENTER'
@@ -276,9 +321,9 @@ def caption(text, x, z, y=-0.09, size=0.16):
         sc.collection.objects.link(ob)
 
     for (_t, label), x in zip(top, top_xs):
-        caption(label, x, 4.22)
-    caption("GAMMA_CROSS t=1/2", -0.80, 0.23, y=-0.46, size=0.15)
-    caption("NAIVE LERP t=1/2", 0.80, 0.23, y=-0.46, size=0.15)
+        caption(label, x, 5.62, 0.20)
+    caption("GAMMA_CROSS t=1/2", -1.05, 1.42, 0.20)
+    caption("NAIVE LERP t=1/2", 1.05, 1.42, 0.20)
 
 
 def render_still(sc, got, path, engine):
@@ -286,26 +331,6 @@ def render_still(sc, got, path, engine):
     build_bench(scene, got)
 
     import mathutils, bmesh
-    # a low plinth shelf grounds the bench without eating the frame
-    plinth_me = bpy.data.meshes.new("Plinth")
-    bm2 = bmesh.new()
-    try:
-        bmesh.ops.create_cube(bm2, size=1.0,
-                              matrix=mathutils.Matrix.Diagonal((6.9, 1.3, 0.45, 1.0)))
-        bm2.to_mesh(plinth_me)
-    finally:
-        bm2.free()
-    cmat = bpy.data.materials.new("ConsoleMetal")
-    cmat.use_nodes = True
-    cc = cmat.node_tree.nodes["Principled BSDF"]
-    cc.inputs["Base Color"].default_value = (0.07, 0.08, 0.09, 1.0)
-    cc.inputs["Metallic"].default_value = 0.7
-    cc.inputs["Roughness"].default_value = 0.5
-    plinth_me.materials.append(cmat)
-    plinth = bpy.data.objects.new("Plinth", plinth_me)
-    plinth.location = (0.0, 0.2, 0.225)
-    scene.collection.objects.link(plinth)
-
     floor_me = bpy.data.meshes.new("Floor")
     bm = bmesh.new()
     try:
@@ -341,20 +366,21 @@ def light(name, loc, energy, size, col, target):
         scene.collection.objects.link(ob)
 
     # shaped warm key, faint cool fill, cool rim, and the signature warm
-    # wedge between bench and wall raking a pool onto the backdrop — the
+    # wedge between booth and wall raking a pool onto the backdrop — the
     # wall itself stays near-black outside the pool (docs/VISUAL-STYLE.md)
-    light("Key", (-4.0, -4.0, 6.5), 420.0, 4.0, (1.0, 0.96, 0.9), (0.0, 0.0, 1.8))
-    light("Fill", (5.0, -3.5, 2.5), 80.0, 9.0, (0.75, 0.85, 1.0), (0.5, 0.0, 1.6))
-    light("Rim", (0.5, 4.0, 6.0), 260.0, 4.0, (0.6, 0.78, 1.0), (0.0, 0.0, 2.6))
-    light("Wedge", (1.2, 5.0, 4.5), 340.0, 5.0, (1.0, 0.76, 0.5), (-0.2, 9.0, 1.2))
+    light("Key", (-4.0, -4.5, 7.0), 460.0, 4.5, (1.0, 0.96, 0.9), (0.0, 0.2, 3.0))
+    light("Fill", (6.0, -3.0, 3.0), 90.0, 9.0, (0.75, 0.85, 1.0), (0.5, 0.0, 2.8))
+    light("Rim", (0.5, 4.5, 7.0), 320.0, 4.0, (0.6, 0.78, 1.0), (0.0, 0.3, 4.2))
+    light("Wedge", (0.5, 5.5, 6.0), 420.0, 5.5, (1.0, 0.76, 0.5), (0.5, 9.0, 4.2))
 
+    # 3/4 angle from the right: the booth shows face, side, and cast shadow
     cam_data = bpy.data.cameras.new("Cam")
     cam_data.lens = 50.0
     cam = bpy.data.objects.new("Cam", cam_data)
-    cam.location = (0.7, -13.0, 3.4)
+    cam.location = (9.7, -17.5, 5.7)
     scene.collection.objects.link(cam)
     target = bpy.data.objects.new("Aim", None)
-    target.location = (0.0, 0.0, 2.15)
+    target.location = (0.0, 0.2, 3.2)
     scene.collection.objects.link(target)
     con = cam.constraints.new('TRACK_TO')
     con.target = target