diff --git a/README.md b/README.md
index 144be1d..d2d162e 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 over a LINKED plaque beside a dim steel decoy over UNLINKED on a dark studio floor - 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 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>
 </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 - eight emissive panels fading crimson to teal across the cross, with the brighter naive-lerp midpoint framed in hazard orange on the console below" /></a>
+<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>
 </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 c3be2c9..25ac8dc 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 170f42a..007ce70 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 fc62a7c..145fd82 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 ec1c42b..e5b1816 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 3e5be68..59f0b8b 100644
--- a/docs/gallery/index.html
+++ b/docs/gallery/index.html
@@ -524,14 +524,14 @@ <h2><a href="vse-gamma-cross/">vse-gamma-cross</a></h2>
           <a class="card-link" href="vse-gamma-cross/">View example <span aria-hidden="true">&rarr;</span></a>
         </div>
       </article>
-      <article class="card" data-tags="rendering">
+      <article class="card" data-tags="rendering objects">
         <a class="card-media" href="light-link-studio/" aria-label="light-link-studio example detail page">
           <img src="assets/light-link-studio-hero.webp" alt="light-link-studio — One key, one hero: a light linked to a receiver collection lights only the hero, proven by two pixel renders in one pass." loading="lazy" decoding="async" />
         </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: 4.0x luminance ratio; unlinked in the same check: the decoy rises 244% 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 Next honors linking too (5.5x on 4.5, 5.9x on 5.1), 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 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>
           <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 9721638..0debdd8 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: 4.0x luminance ratio; unlinked in the same check: the decoy rises 244% 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 206% while the hero holds at 0.0% 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: 4.0x luminance ratio; unlinked in the same check: the decoy rises 244% 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 206% while the hero holds at 0.0% 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: 4.0x luminance ratio; unlinked in the same check: the decoy rises 244% 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 206% while the hero holds at 0.0% 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: 4.0x luminance ratio; unlinked in the same check: the decoy rises 244% 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 206% while the hero holds at 0.0% 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 Next honors linking too (5.5x on 4.5, 5.9x on 5.1), 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.7x 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>
-<p>1. <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. 2. <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>4.0x</strong> (gate ≥ 3x), measured at each sphere&#x27;s *projected* center so framing can&#x27;t move the sample off the subject. 3. <strong>Unlinked (same check), the restriction vanishes surgically.</strong> Render two: the decoy rises <strong>244–251%</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. 4. <strong>The engine note, verified rather than assumed.</strong> Light linking also works on EEVEE Next — measured 5.5x linked ratio on 4.5.11 EEVEE Next and 5.9x on 5.1.2 EEVEE, matching Cycles within sampling noise. The check still pins Cycles for deterministic tiny-sample CPU renders; luminance gates need <code>view_transform = &#x27;Standard&#x27;</code> (AgX compresses the ratios).</p>
-<p><strong>What each check catches on failure:</strong> inverting the link to the decoy collection (exit 6 — hero drops to 0.179, ratio collapses to 0.22x), 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 (4.0x linked both; rise 244% vs 251% within sampling noise).</p>
-<p>The render is the contract at a glance: the blazing orange hero over the LINKED plaque, the cold steel decoy over UNLINKED — one key, one hero.</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>
+<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>
 <h2>Run</h2>
 <pre><code># Two-render correctness check (tiny Cycles CPU renders) — the CI check:
 blender --background --python light_link_studio.py --
@@ -217,10 +217,12 @@ <h2>Source</h2>
    hero&#x27;s is unchanged within tolerance — the link is surgical, not a dimmer.
 
 The engine note, verified rather than assumed: light linking also works on
-EEVEE Next — measured 5.5x linked ratio on 4.5.11 EEVEE Next and 5.9x on
-5.1.2 EEVEE, matching Cycles within sampling noise. The check still pins
-Cycles for deterministic tiny-sample CPU renders. The API is stable between
-Blender 4.5 LTS and 5.1 (ObjectLightLinking with
+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,
+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
 receiver_collection/blocker_collection on both).
 
 By default it runs the two-render correctness check (no gallery still) — the
@@ -231,11 +233,10 @@ <h2>Source</h2>
 &quot;&quot;&quot;</span>
 <span class="k">import</span> bpy, bmesh, sys, os, math, argparse, tempfile, shutil
 
-IS_5X = bpy.app.version &gt;= (<span class="n">5</span>, <span class="n">0</span>, <span class="n">0</span>)
 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">450.0</span>
-FILL_ENERGY = <span class="n">18.0</span>
+KEY_ENERGY = <span class="n">560.0</span>
+FILL_ENERGY = <span class="n">26.0</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>
@@ -257,7 +258,7 @@ <h2>Source</h2>
     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 = <span class="n">0.45</span>
+    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>)
@@ -265,14 +266,20 @@ <h2>Source</h2>
     <span class="k">return</span> ob
 
 
-<span class="k">def</span> add_light(sc, name, energy, loc, rot, color, size=<span class="n">1.2</span>):
+<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
     ld.size = size
     ld.color = color
     ob = bpy.data.objects.new(name, ld)
     ob.location = loc
-    ob.rotation_euler = tuple(math.radians(a) <span class="k">for</span> a <span class="k">in</span> rot)
+    <span class="k">if</span> aim <span class="k">is</span> <span class="k">not</span> <span class="k">None</span>:
+        con = ob.constraints.new(<span class="s">&#x27;TRACK_TO&#x27;</span>)
+        con.target = aim
+        con.track_axis = <span class="s">&#x27;TRACK_NEGATIVE_Z&#x27;</span>
+        con.up_axis = <span class="s">&#x27;UP_Y&#x27;</span>
+    <span class="k">else</span>:
+        ob.rotation_euler = tuple(math.radians(a) <span class="k">for</span> a <span class="k">in</span> rot)
     sc.collection.objects.link(ob)
     <span class="k">return</span> ob
 
@@ -311,30 +318,40 @@ <h2>Source</h2>
     world.node_tree.nodes[<span class="s">&quot;Background&quot;</span>].inputs[<span class="s">&quot;Color&quot;</span>].default_value = (<span class="n">0.02</span>, <span class="n">0.021</span>, <span class="n">0.025</span>, <span class="n">1.0</span>)
     sc.world = world
 
-    key = add_light(sc, <span class="s">&quot;Key&quot;</span>, KEY_ENERGY, (-<span class="n">2.2</span>, -<span class="n">2.5</span>, <span class="n">3.5</span>), (<span class="n">40</span>, <span class="n">0</span>, -<span class="n">25</span>),
-                    (<span class="n">1.0</span>, <span class="n">0.92</span>, <span class="n">0.82</span>), size=<span class="n">1.4</span>)
-    add_light(sc, <span class="s">&quot;Fill&quot;</span>, FILL_ENERGY, (<span class="n">3.0</span>, -<span class="n">2.0</span>, <span class="n">2.2</span>), (<span class="n">60</span>, <span class="n">0</span>, <span class="n">35</span>),
-              (<span class="n">0.75</span>, <span class="n">0.85</span>, <span class="n">1.0</span>), size=<span class="n">4.0</span>)
-    add_light(sc, <span class="s">&quot;Rim&quot;</span>, <span class="n">120.0</span>, (<span class="n">0.5</span>, <span class="n">4.5</span>, <span class="n">4.0</span>), (-<span class="n">55</span>, <span class="n">0</span>, <span class="n">175</span>),
-              (<span class="n">0.6</span>, <span class="n">0.78</span>, <span class="n">1.0</span>), size=<span class="n">3.0</span>)
-    <span class="c"># the signature warm wedge raking the back wall (docs/VISUAL-STYLE.md)</span>
-    add_light(sc, <span class="s">&quot;Wedge&quot;</span>, <span class="n">250.0</span>, (-<span class="n">2.5</span>, <span class="n">3.5</span>, <span class="n">4.2</span>), (-<span class="n">72</span>, <span class="n">0</span>, <span class="n">165</span>),
-              (<span class="n">1.0</span>, <span class="n">0.76</span>, <span class="n">0.5</span>), size=<span class="n">5.0</span>)
+    <span class="c"># every subject light is aimed at the aim empty, so no cone grazes the</span>
+    <span class="c"># floor/wall seam into a bright band (docs/VISUAL-STYLE.md)</span>
+    aim = bpy.data.objects.new(<span class="s">&quot;Aim&quot;</span>, <span class="k">None</span>)
+    aim.location = (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.4</span>)
+    sc.collection.objects.link(aim)
+
+    key = add_light(sc, <span class="s">&quot;Key&quot;</span>, KEY_ENERGY, (-<span class="n">3.0</span>, -<span class="n">3.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>), size=<span class="n">4.5</span>, aim=aim)
+    add_light(sc, <span class="s">&quot;Fill&quot;</span>, FILL_ENERGY, (<span class="n">3.2</span>, -<span class="n">1.6</span>, <span class="n">1.8</span>),
+              (<span class="n">0.75</span>, <span class="n">0.85</span>, <span class="n">1.0</span>), size=<span class="n">4.5</span>, aim=aim)
+    add_light(sc, <span class="s">&quot;Rim&quot;</span>, <span class="n">200.0</span>, (<span class="n">0.5</span>, <span class="n">4.5</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>), size=<span class="n">2.5</span>, aim=aim)
+    <span class="c"># the signature warm wedge: between the subjects and the wall, raking the</span>
+    <span class="c"># wall low so a soft warm pool sits behind the hero just above the seam</span>
+    add_light(sc, <span class="s">&quot;Wedge&quot;</span>, <span class="n">500.0</span>, (-<span class="n">2.0</span>, <span class="n">7.0</span>, <span class="n">2.8</span>),
+              (<span class="n">1.0</span>, <span class="n">0.76</span>, <span class="n">0.5</span>), size=<span class="n">5.0</span>, rot=(-<span class="n">49</span>, <span class="n">0</span>, <span class="n">166</span>))
 
     cam = bpy.data.cameras.new(<span class="s">&quot;Cam&quot;</span>)
-    cam.lens = <span class="n">55.0</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">5.9</span>, <span class="n">1.32</span>)
-    cam_ob.rotation_euler = (math.radians(<span class="n">86</span>), <span class="n">0.0</span>, <span class="n">0.0</span>)
+    cam_ob.location = (<span class="n">0.0</span>, -<span class="n">6.2</span>, <span class="n">2.0</span>)
+    con = cam_ob.constraints.new(<span class="s">&#x27;TRACK_TO&#x27;</span>)
+    con.target = aim
+    con.track_axis = <span class="s">&#x27;TRACK_NEGATIVE_Z&#x27;</span>
+    con.up_axis = <span class="s">&#x27;UP_Y&#x27;</span>
     sc.collection.objects.link(cam_ob)
     sc.camera = cam_ob
     <span class="k">return</span> hero, decoy, hero_c, key
 
 
 <span class="k">def</span> setup_render(sc, w, h, samples):
-    <span class="c"># Cycles for deterministic tiny CPU samples; EEVEE Next honors linking</span>
-    <span class="c"># too (measured on both supported versions), but its sampling is not</span>
-    <span class="c"># deterministic enough for a luminance gate</span>
+    <span class="c"># Cycles for deterministic tiny CPU samples; EEVEE honors linking too</span>
+    <span class="c"># (measured with an authoring probe on both supported versions), but</span>
+    <span class="c"># its sampling is not deterministic enough for a luminance gate</span>
     sc.render.engine = <span class="s">&#x27;CYCLES&#x27;</span>
     sc.cycles.samples = samples
     sc.cycles.use_denoising = <span class="k">False</span>
@@ -433,10 +450,6 @@ <h2>Source</h2>
     <span class="k">return</span> <span class="n">0</span>
 
 
-<span class="k">def</span> eevee_engine_id():
-    <span class="k">return</span> <span class="s">&#x27;BLENDER_EEVEE&#x27;</span> <span class="k">if</span> bpy.app.version &gt;= (<span class="n">5</span>, <span class="n">0</span>, <span class="n">0</span>) <span class="k">else</span> <span class="s">&#x27;BLENDER_EEVEE_NEXT&#x27;</span>
-
-
 <span class="k">def</span> plaque(sc, text, x):
     pm = bpy.data.materials.new(<span class="s">&quot;PlaqueMetal&quot;</span>)
     pm.use_nodes = <span class="k">True</span>
@@ -444,22 +457,24 @@ <h2>Source</h2>
     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 LINKED plaque must read even in the decoy&#x27;s dark</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>)
     cu.body = text
     cu.align_x = <span class="s">&#x27;CENTER&#x27;</span>
-    cu.size = <span class="n">0.20</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)
-    ob.location = (x, -<span class="n">0.68</span>, <span class="n">0.01</span>)
+    <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)
     sc.collection.objects.link(ob)
 
 
-<span class="k">def</span> render_still(sc, path, engine):
+<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>)
     <span class="c"># the gallery still is the linked state, on Cycles for the same</span>
@@ -481,8 +496,6 @@ <h2>Source</h2>
     argv = sys.argv[sys.argv.index(<span class="s">&quot;--&quot;</span>) + <span class="n">1</span>:] <span class="k">if</span> <span class="s">&quot;--&quot;</span> <span class="k">in</span> sys.argv <span class="k">else</span> []
     p = argparse.ArgumentParser()
     p.add_argument(<span class="s">&quot;--output&quot;</span>, default=<span class="k">None</span>, help=<span class="s">&quot;optional: render a still PNG here&quot;</span>)
-    p.add_argument(<span class="s">&quot;--engine&quot;</span>, default=<span class="s">&quot;cycles&quot;</span>, choices=(<span class="s">&quot;cycles&quot;</span>,),
-                   help=<span class="s">&quot;render engine — pinned to cycles for deterministic samples&quot;</span>)
     args = p.parse_args(argv)
 
     bpy.ops.wm.read_factory_settings(use_empty=<span class="k">True</span>)
@@ -493,7 +506,7 @@ <h2>Source</h2>
         <span class="k">return</span> code
 
     <span class="k">if</span> args.output:
-        <span class="k">if</span> <span class="k">not</span> render_still(sc, os.path.abspath(args.output), args.engine):
+        <span class="k">if</span> <span class="k">not</span> render_still(sc, os.path.abspath(args.output)):
             print(<span class="s">&quot;ERROR: render produced no file&quot;</span>, file=sys.stderr)
             <span class="k">return</span> <span class="n">9</span>
         print(<span class="s">f&quot;</span><span class="s">rendered still </span>{args.output}<span class="s">&quot;</span>)
diff --git a/docs/gallery/vse-gamma-cross/index.html b/docs/gallery/vse-gamma-cross/index.html
index 8c32fbd..36993ef 100644
--- a/docs/gallery/vse-gamma-cross/index.html
+++ b/docs/gallery/vse-gamma-cross/index.html
@@ -185,10 +185,10 @@ <h1>vse-gamma-cross</h1>
     <section class="detail-section md">
 <p>A runnable follow-up to <a href="https://github.com/TMHSDigital/Blender-Developer-Tools/tree/main/examples/vse-cut-list"><code>vse-cut-list</code></a>: the check renders tiny frames across a GAMMA_CROSS between crimson and teal strips and asserts every sample against the fade&#x27;s actual math — because AI-generated sequencer code assumes the cross is the naive linear mix, and it is not.</p>
 <p><strong>What it witnesses:</strong> the fade math and the frame convention behind it.</p>
-<p>1. <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 asserts every sample 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). 2. <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. An endpoint-inclusive convention is off by a full frame-step (probe: exit 5 at t 0.129 vs 0.125). 3. <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.</p>
+<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 a mixing bench: the eight authentic cross samples as emissive panels fading crimson to teal, with the naive lerp midpoint framed in hazard orange below — visibly brighter than the true mid, the gamma dip made visible.</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>
 <h2>Run</h2>
 <pre><code># Correctness check (tiny per-frame sample renders) — the CI check:
 blender --background --python vse_gamma_cross.py --
@@ -214,7 +214,7 @@ <h2>Source</h2>
 
 so the mid-cross dips below the sRGB lerp — from crimson (0.85, 0.10, 0.22)
 and teal (0.06, 0.75, 0.80) the midpoint is (0.341, 0.349, 0.463), a full
-0.114 darker on the red channel than the lerp (0.455, 0.425, 0.510). The
+0.115 darker on the red channel than the lerp (0.455, 0.425, 0.510). The
 check renders tiny frames across the cross and asserts every sample against
 the closed form, plus that the lerp deviation at mid is material.
 
@@ -244,13 +244,16 @@ <h2>Source</h2>
 Q_TOL = <span class="n">5e-3</span>                  <span class="c"># 2x the 8-bit quantization step + gamma-fit residual (measured 2.93e-3)</span>
 LERP_MID_MIN = <span class="n">0.05</span>           <span class="c"># the gamma dip must be material at t=0.5</span>
 
-<span class="c"># sample frames 1,5,9,...,29 -&gt; t = 0, 1/8, ..., 7/8 exactly</span>
-SAMPLES = [(<span class="n">1</span> + <span class="n">4</span> * k, k / <span class="n">8</span>) <span class="k">for</span> k <span class="k">in</span> range(<span class="n">8</span>)]
+<span class="c"># sample frames 1,5,9,...,29 -&gt; t = 0, 1/8, ..., 7/8 exactly, plus the final</span>
+<span class="c"># frame of the span: t = (duration-1)/duration — B never arrives inside the</span>
+<span class="c"># effect, and that endpoint frame is rendered and asserted like the rest</span>
+SAMPLES = [(<span class="n">1</span> + <span class="n">4</span> * k, k / <span class="n">8</span>) <span class="k">for</span> k <span class="k">in</span> range(<span class="n">8</span>)] + [(<span class="n">32</span>, <span class="n">31</span> / <span class="n">32</span>)]
 
 
 <span class="k">def</span> strips_coll(se):
-    <span class="s">&quot;&quot;&quot;The version-safe accessor: .strips everywhere, never .sequences.&quot;&quot;&quot;</span>
-    <span class="k">return</span> se.strips <span class="k">if</span> hasattr(se, <span class="s">&quot;strips&quot;</span>) <span class="k">else</span> se.sequences
+    <span class="s">&quot;&quot;&quot;The only accessor on both supported versions: .strips, never
+    .sequences — that rename is part of what this example witnesses.&quot;&quot;&quot;</span>
+    <span class="k">return</span> se.strips
 
 
 <span class="k">def</span> new_effect(coll, name, typ, ch, span, **kw):
@@ -388,12 +391,17 @@ <h2>Source</h2>
 
 
 <span class="k">def</span> build_bench(sc, got):
-    <span class="s">&quot;&quot;&quot;The mixing bench: the 8 authentic cross samples as emissive panels,
-    plus the naive lerp midpoint framed in hazard orange for contrast.&quot;&quot;&quot;</span>
+    <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="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, hot=<span class="k">False</span>):
+    <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>)
         mat.use_nodes = <span class="k">True</span>
         nt = mat.node_tree
@@ -407,16 +415,18 @@ <h2>Source</h2>
         bm = bmesh.new()
         <span class="k">try</span>:
             bmesh.ops.create_cube(bm, size=<span class="n">1.0</span>,
-                                  matrix=__import__(<span class="s">&quot;mathutils&quot;</span>).Matrix.Diagonal(
-                                      (<span class="n">0.56</span>, <span class="n">0.10</span>, <span class="n">0.66</span>, <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>)))
             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, <span class="n">0.0</span>, z)
+        ob.location = (x, y, z)
         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>]
@@ -426,25 +436,29 @@ <h2>Source</h2>
             bm = bmesh.new()
             <span class="k">try</span>:
                 bmesh.ops.create_cube(bm, size=<span class="n">1.0</span>,
-                                      matrix=__import__(<span class="s">&quot;mathutils&quot;</span>).Matrix.Diagonal(
-                                          (<span class="n">0.62</span>, <span class="n">0.06</span>, <span class="n">0.72</span>, <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, <span class="n">0.07</span>, z)
+            fob.location = (x, y + <span class="n">0.075</span>, z)
             sc.collection.objects.link(fob)
 
-    <span class="c"># two rows: the authentic fade across the top, the naive mid below it,</span>
-    <span class="c"># framed — the gamma dip is the visible contrast</span>
-    xs = [(-<span class="n">2.17</span> + <span class="n">0.62</span> * i) <span class="k">for</span> i <span class="k">in</span> range(<span class="n">8</span>)]
-    <span class="k">for</span> (f, _t), x <span class="k">in</span> zip(SAMPLES, xs):
-        panel(<span class="s">f&quot;</span><span class="s">t</span>{_t}<span class="s">&quot;</span>, got[f], x, z=<span class="n">1.85</span>)
-    lerp_rgb = 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>))
-    panel(<span class="s">&quot;lerp_mid&quot;</span>, lerp_rgb, <span class="n">0.45</span>, z=<span class="n">0.90</span>, hot=<span class="k">True</span>)
-
-    <span class="c"># captions</span>
+    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>)]
+    <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>
     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>]
@@ -452,35 +466,25 @@ <h2>Source</h2>
     cb.inputs[<span class="s">&quot;Metallic&quot;</span>].default_value = <span class="n">0.2</span>
     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.35</span>, <span class="n">0.37</span>, <span class="n">0.42</span>, <span class="n">1.0</span>)
-    cb.inputs[<span class="s">&quot;Emission Strength&quot;</span>].default_value = <span class="n">0.6</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>
 
-    <span class="k">def</span> caption(text, x, z):
+    <span class="k">def</span> caption(text, x, z, y=-<span class="n">0.09</span>, size=<span class="n">0.16</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>
-        cu.size = <span class="n">0.14</span>
+        cu.size = size
         cu.extrude = <span class="n">0.004</span>
         ob = bpy.data.objects.new(<span class="s">&quot;Caption&quot;</span>, cu)
-        ob.location = (x, -<span class="n">0.09</span>, z)
+        ob.location = (x, y, z)
         ob.rotation_euler = (m.radians(<span class="n">90</span>), <span class="n">0.0</span>, <span class="n">0.0</span>)
         ob.data.materials.append(cu_mat)
         sc.collection.objects.link(ob)
 
-    caption(<span class="s">&quot;GAMMA_CROSS&quot;</span>, <span class="n">0.0</span>, <span class="n">2.45</span>)
-    caption(<span class="s">&quot;t=0&quot;</span>, -<span class="n">2.50</span>, <span class="n">1.40</span>)
-    caption(<span class="s">&quot;t=1/2&quot;</span>, <span class="n">0.02</span>, <span class="n">1.40</span>)
-    caption(<span class="s">&quot;t=7/8&quot;</span>, <span class="n">2.54</span>, <span class="n">1.40</span>)
-    <span class="c"># on the floor in front of the console, facing up like the arc plaques</span>
-    cu = bpy.data.curves.new(<span class="s">&quot;Caption&quot;</span>, <span class="s">&#x27;FONT&#x27;</span>)
-    cu.body = <span class="s">&quot;NAIVE LERP t=1/2&quot;</span>
-    cu.align_x = <span class="s">&#x27;CENTER&#x27;</span>
-    cu.size = <span class="n">0.14</span>
-    cu.extrude = <span class="n">0.004</span>
-    ob = bpy.data.objects.new(<span class="s">&quot;Caption&quot;</span>, cu)
-    ob.location = (<span class="n">0.45</span>, -<span class="n">0.75</span>, <span class="n">0.01</span>)
-    ob.data.materials.append(cu_mat)
-    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>)
 
 
 <span class="k">def</span> render_still(sc, got, path, engine):
@@ -488,12 +492,13 @@ <h2>Source</h2>
     build_bench(scene, got)
 
     <span class="k">import</span> mathutils, bmesh
-    console_me = bpy.data.meshes.new(<span class="s">&quot;Console&quot;</span>)
+    <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">5.6</span>, <span class="n">0.9</span>, <span class="n">0.5</span>, <span class="n">1.0</span>)))
-        bm2.to_mesh(console_me)
+                              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>)
@@ -502,13 +507,12 @@ <h2>Source</h2>
     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>
-    console_me.materials.append(cmat)
-    console = bpy.data.objects.new(<span class="s">&quot;Console&quot;</span>, console_me)
-    console.location = (<span class="n">0.0</span>, <span class="n">0.15</span>, <span class="n">0.25</span>)
-    scene.collection.objects.link(console)
+    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>)
-    <span class="k">import</span> bmesh
     bm = bmesh.new()
     <span class="k">try</span>:
         bmesh.ops.create_grid(bm, x_segments=<span class="n">1</span>, y_segments=<span class="n">1</span>, size=<span class="n">30.0</span>)
@@ -533,28 +537,30 @@ <h2>Source</h2>
     world.node_tree.nodes[<span class="s">&quot;Background&quot;</span>].inputs[<span class="s">&quot;Color&quot;</span>].default_value = (<span class="n">0.02</span>, <span class="n">0.021</span>, <span class="n">0.025</span>, <span class="n">1.0</span>)
     scene.world = world
 
-    <span class="k">def</span> light(name, loc, energy, size, col, rot):
+    <span class="k">def</span> light(name, loc, energy, size, col, target):
         ld = bpy.data.lights.new(name, <span class="s">&#x27;AREA&#x27;</span>)
         ld.energy = energy; ld.size = size; ld.color = col
         ob = bpy.data.objects.new(name, ld)
         ob.location = loc
-        ob.rotation_euler = tuple(math.radians(a) <span class="k">for</span> a <span class="k">in</span> rot)
+        d = mathutils.Vector(target) - ob.location
+        ob.rotation_euler = d.to_track_quat(<span class="s">&#x27;-Z&#x27;</span>, <span class="s">&#x27;Y&#x27;</span>).to_euler()
         scene.collection.objects.link(ob)
 
-    <span class="c"># shaped warm key, faint cool fill, cool rim, warm wedge on the back wall</span>
-    <span class="c"># (docs/VISUAL-STYLE.md)</span>
-    light(<span class="s">&quot;Key&quot;</span>, (-<span class="n">4.0</span>, -<span class="n">5.0</span>, <span class="n">6.0</span>), <span class="n">500.0</span>, <span class="n">4.5</span>, (<span class="n">1.0</span>, <span class="n">0.96</span>, <span class="n">0.9</span>), (<span class="n">48</span>, <span class="n">0</span>, -<span class="n">38</span>))
-    light(<span class="s">&quot;Fill&quot;</span>, (<span class="n">5.0</span>, -<span class="n">4.0</span>, <span class="n">3.0</span>), <span class="n">90.0</span>, <span class="n">9.0</span>, (<span class="n">0.75</span>, <span class="n">0.85</span>, <span class="n">1.0</span>), (<span class="n">62</span>, <span class="n">0</span>, <span class="n">50</span>))
-    light(<span class="s">&quot;Rim&quot;</span>, (<span class="n">0.5</span>, <span class="n">4.5</span>, <span class="n">5.0</span>), <span class="n">300.0</span>, <span class="n">4.0</span>, (<span class="n">0.6</span>, <span class="n">0.78</span>, <span class="n">1.0</span>), (-<span class="n">55</span>, <span class="n">0</span>, <span class="n">175</span>))
-    light(<span class="s">&quot;Wedge&quot;</span>, (<span class="n">2.5</span>, <span class="n">3.5</span>, <span class="n">4.2</span>), <span class="n">460.0</span>, <span class="n">6.0</span>, (<span class="n">1.0</span>, <span class="n">0.76</span>, <span class="n">0.5</span>), (-<span class="n">72</span>, <span class="n">0</span>, <span class="n">195</span>))
+    <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"># 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>))
 
     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.3</span>, -<span class="n">9.2</span>, <span class="n">2.5</span>)
+    cam.location = (<span class="n">0.7</span>, -<span class="n">13.0</span>, <span class="n">3.4</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.15</span>, <span class="n">0.0</span>, <span class="n">1.35</span>)
+    target.location = (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">2.15</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 1f11be3..1fde9ef 100644
--- a/examples/gallery.json
+++ b/examples/gallery.json
@@ -361,12 +361,13 @@
     {
       "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: 4.0x luminance ratio; unlinked in the same check: the decoy rises 244% 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 Next honors linking too (5.5x on 4.5, 5.9x on 5.1), 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 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.",
       "hero": "docs/gallery/assets/light-link-studio-hero.webp",
       "preview": "examples/light-link-studio/preview.webp",
       "tags": [
-        "rendering"
+        "rendering",
+        "objects"
       ]
     }
   ]
diff --git a/examples/light-link-studio/README.md b/examples/light-link-studio/README.md
index 1bcb78b..dbbe8c1 100644
--- a/examples/light-link-studio/README.md
+++ b/examples/light-link-studio/README.md
@@ -7,36 +7,43 @@ most often misses or misaddresses.
 
 **What it witnesses:** the light-linking contract and the traps around it.
 
-1. **The API is on the light OBJECT, not the Light datablock.**
-   `ld.light_linking` is an AttributeError on both versions (verified); the
-   path is `obj.light_linking.receiver_collection` (ObjectLightLinking, with
-   `blocker_collection` alongside). Assignment reads back through the API.
-2. **Linked, the key lights only the receiver collection.** Render one:
-   hero well-lit, decoy at the fill floor — hero/decoy luminance ratio
-   **4.0x** (gate ≥ 3x), measured at each sphere's *projected* center so
-   framing can't move the sample off the subject.
-3. **Unlinked (same check), the restriction vanishes surgically.** Render
-   two: the decoy rises **244–251%** while the hero drifts **0.0%** — the
-   link restricts without dimming anything else. The shipped check therefore
-   demonstrates both states, not just one.
-4. **The engine note, verified rather than assumed.** Light linking also
-   works on EEVEE Next — measured 5.5x linked ratio on 4.5.11 EEVEE Next and
-   5.9x on 5.1.2 EEVEE, matching Cycles within sampling noise. The check
-   still pins Cycles for deterministic tiny-sample CPU renders; luminance
-   gates need `view_transform = 'Standard'` (AgX compresses the ratios).
+- **The API is on the light OBJECT, not the Light datablock.**
+  `ld.light_linking` is an AttributeError on both versions (verified); the
+  path is `obj.light_linking.receiver_collection` (ObjectLightLinking, with
+  `blocker_collection` alongside). Assignment reads back through the API.
+- **Linked, the key lights only the receiver collection.** Render one:
+  hero well-lit, decoy at the fill floor — hero/decoy luminance ratio
+  **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
+  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
+  absolute shifts in that base swing the relative rise between versions and
+  runs — the gate is a conservative ≥ 50%.
+- **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
+  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
+  compresses the ratios).
 
 **What each check catches on failure:** inverting the link to the decoy
-collection (exit 6 — hero drops to 0.179, ratio collapses to 0.22x), an
+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'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 (4.0x linked both; rise 244% vs 251% within sampling
-noise).
+Blender 4.5 LTS and 5.1 (3.4x vs 3.6x linked; rise 213% vs 206% — 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 — one key, one hero.
+LINKED plaque, the cold steel decoy over UNLINKED, 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 2650339..b5a1d0c 100644
--- a/examples/light-link-studio/light_link_studio.py
+++ b/examples/light-link-studio/light_link_studio.py
@@ -12,10 +12,12 @@
    hero's is unchanged within tolerance — the link is surgical, not a dimmer.
 
 The engine note, verified rather than assumed: light linking also works on
-EEVEE Next — measured 5.5x linked ratio on 4.5.11 EEVEE Next and 5.9x on
-5.1.2 EEVEE, matching Cycles within sampling noise. The check still pins
-Cycles for deterministic tiny-sample CPU renders. The API is stable between
-Blender 4.5 LTS and 5.1 (ObjectLightLinking with
+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,
+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
 receiver_collection/blocker_collection on both).
 
 By default it runs the two-render correctness check (no gallery still) — the
@@ -26,11 +28,10 @@
 """
 import bpy, bmesh, sys, os, math, argparse, tempfile, shutil
 
-IS_5X = bpy.app.version >= (5, 0, 0)
 HERO_RGB = (0.85, 0.30, 0.08)     # hazard orange
 DECOY_RGB = (0.30, 0.34, 0.40)    # cold steel
-KEY_ENERGY = 450.0
-FILL_ENERGY = 18.0
+KEY_ENERGY = 560.0
+FILL_ENERGY = 26.0
 PXW, PXH = 64, 36
 RATIO_MIN = 3.0                   # hero/decoy luminance ratio, linked
 HERO_LUMA_MIN = 0.25              # hero must be well-lit, linked
@@ -52,7 +53,7 @@ def sphere(name, rgb, x, coll):
     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 = 0.45
+    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)
@@ -60,14 +61,20 @@ def sphere(name, rgb, x, coll):
     return ob
 
 
-def add_light(sc, name, energy, loc, rot, color, size=1.2):
+def add_light(sc, name, energy, loc, color, size, aim=None, rot=None):
     ld = bpy.data.lights.new(name, 'AREA')
     ld.energy = energy
     ld.size = size
     ld.color = color
     ob = bpy.data.objects.new(name, ld)
     ob.location = loc
-    ob.rotation_euler = tuple(math.radians(a) for a in rot)
+    if aim is not None:
+        con = ob.constraints.new('TRACK_TO')
+        con.target = aim
+        con.track_axis = 'TRACK_NEGATIVE_Z'
+        con.up_axis = 'UP_Y'
+    else:
+        ob.rotation_euler = tuple(math.radians(a) for a in rot)
     sc.collection.objects.link(ob)
     return ob
 
@@ -106,30 +113,40 @@ def build_studio(sc):
     world.node_tree.nodes["Background"].inputs["Color"].default_value = (0.02, 0.021, 0.025, 1.0)
     sc.world = world
 
-    key = add_light(sc, "Key", KEY_ENERGY, (-2.2, -2.5, 3.5), (40, 0, -25),
-                    (1.0, 0.92, 0.82), size=1.4)
-    add_light(sc, "Fill", FILL_ENERGY, (3.0, -2.0, 2.2), (60, 0, 35),
-              (0.75, 0.85, 1.0), size=4.0)
-    add_light(sc, "Rim", 120.0, (0.5, 4.5, 4.0), (-55, 0, 175),
-              (0.6, 0.78, 1.0), size=3.0)
-    # the signature warm wedge raking the back wall (docs/VISUAL-STYLE.md)
-    add_light(sc, "Wedge", 250.0, (-2.5, 3.5, 4.2), (-72, 0, 165),
-              (1.0, 0.76, 0.5), size=5.0)
+    # every subject light is aimed at the aim empty, so no cone grazes the
+    # floor/wall seam into a bright band (docs/VISUAL-STYLE.md)
+    aim = bpy.data.objects.new("Aim", None)
+    aim.location = (0.0, 0.0, 0.4)
+    sc.collection.objects.link(aim)
+
+    key = add_light(sc, "Key", KEY_ENERGY, (-3.0, -3.0, 4.0),
+                    (1.0, 0.96, 0.9), size=4.5, aim=aim)
+    add_light(sc, "Fill", FILL_ENERGY, (3.2, -1.6, 1.8),
+              (0.75, 0.85, 1.0), size=4.5, aim=aim)
+    add_light(sc, "Rim", 200.0, (0.5, 4.5, 4.0),
+              (0.6, 0.78, 1.0), size=2.5, aim=aim)
+    # the signature warm wedge: between the subjects and the wall, raking the
+    # wall low so a soft warm pool sits behind the hero just above the seam
+    add_light(sc, "Wedge", 500.0, (-2.0, 7.0, 2.8),
+              (1.0, 0.76, 0.5), size=5.0, rot=(-49, 0, 166))
 
     cam = bpy.data.cameras.new("Cam")
-    cam.lens = 55.0
+    cam.lens = 50.0
     cam_ob = bpy.data.objects.new("Cam", cam)
-    cam_ob.location = (0.0, -5.9, 1.32)
-    cam_ob.rotation_euler = (math.radians(86), 0.0, 0.0)
+    cam_ob.location = (0.0, -6.2, 2.0)
+    con = cam_ob.constraints.new('TRACK_TO')
+    con.target = aim
+    con.track_axis = 'TRACK_NEGATIVE_Z'
+    con.up_axis = 'UP_Y'
     sc.collection.objects.link(cam_ob)
     sc.camera = cam_ob
     return hero, decoy, hero_c, key
 
 
 def setup_render(sc, w, h, samples):
-    # Cycles for deterministic tiny CPU samples; EEVEE Next honors linking
-    # too (measured on both supported versions), but its sampling is not
-    # deterministic enough for a luminance gate
+    # Cycles for deterministic tiny CPU samples; EEVEE honors linking too
+    # (measured with an authoring probe on both supported versions), but
+    # its sampling is not deterministic enough for a luminance gate
     sc.render.engine = 'CYCLES'
     sc.cycles.samples = samples
     sc.cycles.use_denoising = False
@@ -228,10 +245,6 @@ def check(sc, key, hero_c, hero, decoy):
     return 0
 
 
-def eevee_engine_id():
-    return 'BLENDER_EEVEE' if bpy.app.version >= (5, 0, 0) else 'BLENDER_EEVEE_NEXT'
-
-
 def plaque(sc, text, x):
     pm = bpy.data.materials.new("PlaqueMetal")
     pm.use_nodes = True
@@ -239,22 +252,24 @@ def plaque(sc, text, x):
     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 LINKED plaque must read even in the decoy's dark
+    # 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')
     cu.body = text
     cu.align_x = 'CENTER'
-    cu.size = 0.20
+    cu.size = 0.22
     cu.extrude = 0.006
     ob = bpy.data.objects.new("Plaque", cu)
-    ob.location = (x, -0.68, 0.01)
+    # 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)
     sc.collection.objects.link(ob)
 
 
-def render_still(sc, path, engine):
+def render_still(sc, path):
     plaque(sc, "LINKED", -1.2)
     plaque(sc, "UNLINKED", 1.2)
     # the gallery still is the linked state, on Cycles for the same
@@ -276,8 +291,6 @@ def main():
     argv = sys.argv[sys.argv.index("--") + 1:] if "--" in sys.argv else []
     p = argparse.ArgumentParser()
     p.add_argument("--output", default=None, help="optional: render a still PNG here")
-    p.add_argument("--engine", default="cycles", choices=("cycles",),
-                   help="render engine — pinned to cycles for deterministic samples")
     args = p.parse_args(argv)
 
     bpy.ops.wm.read_factory_settings(use_empty=True)
@@ -288,7 +301,7 @@ def main():
         return code
 
     if args.output:
-        if not render_still(sc, os.path.abspath(args.output), args.engine):
+        if not render_still(sc, os.path.abspath(args.output)):
             print("ERROR: render produced no file", file=sys.stderr)
             return 9
         print(f"rendered still {args.output}")
diff --git a/examples/light-link-studio/preview.webp b/examples/light-link-studio/preview.webp
index fa8e142..ff6961c 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 e9fb6bf..e83fe4c 100644
--- a/examples/vse-gamma-cross/README.md
+++ b/examples/vse-gamma-cross/README.md
@@ -7,23 +7,26 @@ code assumes the cross is the naive linear mix, and it is not.
 
 **What it witnesses:** the fade math and the frame convention behind it.
 
-1. **The cross blends in a gamma-0.5 space.** Not `(1-t)·A + t·B` but
-   `((1-t)·√A + t·√B)²` — the mid-cross dips below the sRGB lerp. From crimson
-   `(0.85, 0.10, 0.22)` and teal `(0.06, 0.75, 0.80)` the midpoint is
-   `(0.341, 0.349, 0.463)`: **0.115 darker** on red than the lerp
-   `(0.455, 0.425, 0.510)`. The check asserts every sample 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).
-2. **`t = (frame − start) / duration`, and it never reaches 1 inside the
-   effect.** The last frame of the span blends at `(duration−1)/duration`;
-   B arrives only when the effect ends. An endpoint-inclusive convention is
-   off by a full frame-step (probe: exit 5 at t 0.129 vs 0.125).
-3. **The pixel witness demands `view_transform = 'Standard'`** — 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's render standard exists to prevent. Also caught: deleting a
-   consumed input strip orphans-and-deletes the effect (`Strip 'GC' not in
-   scene`) — remove effects before their inputs.
+- **The cross blends in a gamma-0.5 space.** Not `(1-t)·A + t·B` but
+  `((1-t)·√A + t·√B)²` — the mid-cross dips below the sRGB lerp. From crimson
+  `(0.85, 0.10, 0.22)` and teal `(0.06, 0.75, 0.80)` the midpoint is
+  `(0.341, 0.349, 0.463)`: **0.115 darker** on red than the lerp
+  `(0.455, 0.425, 0.510)`. 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).
+- **`t = (frame − start) / duration`, and it never reaches 1 inside the
+  effect.** The last frame of the span blends at `(duration−1)/duration`;
+  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).
+- **The pixel witness demands `view_transform = 'Standard'`** — 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's render standard exists to prevent. Also caught: deleting a
+  consumed input strip orphans-and-deletes the effect (`Strip 'GC' not in
+  scene`) — remove effects before their inputs.
 
 **What each check catches on failure:** asserting the naive lerp as the
 expectation (exit 6, deviation 0.1138 at mid), the endpoint-inclusive t
@@ -34,9 +37,12 @@ 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 a mixing bench: the eight authentic cross samples as emissive
-panels fading crimson to teal, with the naive lerp midpoint framed in hazard
-orange below — visibly brighter than the true mid, the gamma dip made visible.
+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.
 
 ## Run
 
diff --git a/examples/vse-gamma-cross/preview.webp b/examples/vse-gamma-cross/preview.webp
index 983df73..4f55e49 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 ffe1d64..79153fd 100644
--- a/examples/vse-gamma-cross/vse_gamma_cross.py
+++ b/examples/vse-gamma-cross/vse_gamma_cross.py
@@ -8,7 +8,7 @@
 
 so the mid-cross dips below the sRGB lerp — from crimson (0.85, 0.10, 0.22)
 and teal (0.06, 0.75, 0.80) the midpoint is (0.341, 0.349, 0.463), a full
-0.114 darker on the red channel than the lerp (0.455, 0.425, 0.510). The
+0.115 darker on the red channel than the lerp (0.455, 0.425, 0.510). The
 check renders tiny frames across the cross and asserts every sample against
 the closed form, plus that the lerp deviation at mid is material.
 
@@ -38,13 +38,16 @@
 Q_TOL = 5e-3                  # 2x the 8-bit quantization step + gamma-fit residual (measured 2.93e-3)
 LERP_MID_MIN = 0.05           # the gamma dip must be material at t=0.5
 
-# sample frames 1,5,9,...,29 -> t = 0, 1/8, ..., 7/8 exactly
-SAMPLES = [(1 + 4 * k, k / 8) for k in range(8)]
+# sample frames 1,5,9,...,29 -> t = 0, 1/8, ..., 7/8 exactly, plus the final
+# frame of the span: t = (duration-1)/duration — B never arrives inside the
+# effect, and that endpoint frame is rendered and asserted like the rest
+SAMPLES = [(1 + 4 * k, k / 8) for k in range(8)] + [(32, 31 / 32)]
 
 
 def strips_coll(se):
-    """The version-safe accessor: .strips everywhere, never .sequences."""
-    return se.strips if hasattr(se, "strips") else se.sequences
+    """The only accessor on both supported versions: .strips, never
+    .sequences — that rename is part of what this example witnesses."""
+    return se.strips
 
 
 def new_effect(coll, name, typ, ch, span, **kw):
@@ -182,12 +185,17 @@ def eevee_engine_id():
 
 
 def build_bench(sc, got):
-    """The mixing bench: the 8 authentic cross samples as emissive panels,
-    plus the naive lerp midpoint framed in hazard orange for contrast."""
+    """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."""
     import bmesh
+    import mathutils
     import math as m
 
-    def panel(name, rgb, x, z, hot=False):
+    def panel(name, rgb, x, z, y=0.0, hot=False):
         mat = bpy.data.materials.new(f"Swatch{name}")
         mat.use_nodes = True
         nt = mat.node_tree
@@ -201,16 +209,18 @@ def panel(name, rgb, x, z, hot=False):
         bm = bmesh.new()
         try:
             bmesh.ops.create_cube(bm, size=1.0,
-                                  matrix=__import__("mathutils").Matrix.Diagonal(
-                                      (0.56, 0.10, 0.66, 1.0)))
+                                  matrix=mathutils.Matrix.Diagonal(
+                                      (1.5, 0.12, 1.65, 1.0)))
             bm.to_mesh(me)
         finally:
             bm.free()
         me.materials.append(mat)
         ob = bpy.data.objects.new(name, me)
-        ob.location = (x, 0.0, z)
+        ob.location = (x, y, z)
         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"]
@@ -220,25 +230,29 @@ def panel(name, rgb, x, z, hot=False):
             bm = bmesh.new()
             try:
                 bmesh.ops.create_cube(bm, size=1.0,
-                                      matrix=__import__("mathutils").Matrix.Diagonal(
-                                          (0.62, 0.06, 0.72, 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, 0.07, z)
+            fob.location = (x, y + 0.075, z)
             sc.collection.objects.link(fob)
 
-    # two rows: the authentic fade across the top, the naive mid below it,
-    # framed — the gamma dip is the visible contrast
-    xs = [(-2.17 + 0.62 * i) for i in range(8)]
-    for (f, _t), x in zip(SAMPLES, xs):
-        panel(f"t{_t}", got[f], x, z=1.85)
-    lerp_rgb = tuple(naive(0.5, k) for k in range(3))
-    panel("lerp_mid", lerp_rgb, 0.45, z=0.90, hot=True)
-
-    # captions
+    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)]
+    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)
     cu_mat = bpy.data.materials.new("CaptionGrey")
     cu_mat.use_nodes = True
     cb = cu_mat.node_tree.nodes["Principled BSDF"]
@@ -246,35 +260,25 @@ def panel(name, rgb, x, z, hot=False):
     cb.inputs["Metallic"].default_value = 0.2
     cb.inputs["Roughness"].default_value = 0.6
     sock = cb.inputs.get("Emission Color") or cb.inputs["Emission"]
-    sock.default_value = (0.35, 0.37, 0.42, 1.0)
-    cb.inputs["Emission Strength"].default_value = 0.6
+    sock.default_value = (0.38, 0.40, 0.45, 1.0)
+    cb.inputs["Emission Strength"].default_value = 0.45
 
-    def caption(text, x, z):
+    def caption(text, x, z, y=-0.09, size=0.16):
         cu = bpy.data.curves.new("Caption", 'FONT')
         cu.body = text
         cu.align_x = 'CENTER'
-        cu.size = 0.14
+        cu.size = size
         cu.extrude = 0.004
         ob = bpy.data.objects.new("Caption", cu)
-        ob.location = (x, -0.09, z)
+        ob.location = (x, y, z)
         ob.rotation_euler = (m.radians(90), 0.0, 0.0)
         ob.data.materials.append(cu_mat)
         sc.collection.objects.link(ob)
 
-    caption("GAMMA_CROSS", 0.0, 2.45)
-    caption("t=0", -2.50, 1.40)
-    caption("t=1/2", 0.02, 1.40)
-    caption("t=7/8", 2.54, 1.40)
-    # on the floor in front of the console, facing up like the arc plaques
-    cu = bpy.data.curves.new("Caption", 'FONT')
-    cu.body = "NAIVE LERP t=1/2"
-    cu.align_x = 'CENTER'
-    cu.size = 0.14
-    cu.extrude = 0.004
-    ob = bpy.data.objects.new("Caption", cu)
-    ob.location = (0.45, -0.75, 0.01)
-    ob.data.materials.append(cu_mat)
-    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)
 
 
 def render_still(sc, got, path, engine):
@@ -282,12 +286,13 @@ def render_still(sc, got, path, engine):
     build_bench(scene, got)
 
     import mathutils, bmesh
-    console_me = bpy.data.meshes.new("Console")
+    # 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((5.6, 0.9, 0.5, 1.0)))
-        bm2.to_mesh(console_me)
+                              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")
@@ -296,13 +301,12 @@ def render_still(sc, got, path, engine):
     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
-    console_me.materials.append(cmat)
-    console = bpy.data.objects.new("Console", console_me)
-    console.location = (0.0, 0.15, 0.25)
-    scene.collection.objects.link(console)
+    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")
-    import bmesh
     bm = bmesh.new()
     try:
         bmesh.ops.create_grid(bm, x_segments=1, y_segments=1, size=30.0)
@@ -327,28 +331,30 @@ def render_still(sc, got, path, engine):
     world.node_tree.nodes["Background"].inputs["Color"].default_value = (0.02, 0.021, 0.025, 1.0)
     scene.world = world
 
-    def light(name, loc, energy, size, col, rot):
+    def light(name, loc, energy, size, col, target):
         ld = bpy.data.lights.new(name, 'AREA')
         ld.energy = energy; ld.size = size; ld.color = col
         ob = bpy.data.objects.new(name, ld)
         ob.location = loc
-        ob.rotation_euler = tuple(math.radians(a) for a in rot)
+        d = mathutils.Vector(target) - ob.location
+        ob.rotation_euler = d.to_track_quat('-Z', 'Y').to_euler()
         scene.collection.objects.link(ob)
 
-    # shaped warm key, faint cool fill, cool rim, warm wedge on the back wall
-    # (docs/VISUAL-STYLE.md)
-    light("Key", (-4.0, -5.0, 6.0), 500.0, 4.5, (1.0, 0.96, 0.9), (48, 0, -38))
-    light("Fill", (5.0, -4.0, 3.0), 90.0, 9.0, (0.75, 0.85, 1.0), (62, 0, 50))
-    light("Rim", (0.5, 4.5, 5.0), 300.0, 4.0, (0.6, 0.78, 1.0), (-55, 0, 175))
-    light("Wedge", (2.5, 3.5, 4.2), 460.0, 6.0, (1.0, 0.76, 0.5), (-72, 0, 195))
+    # shaped warm key, faint cool fill, cool rim, and the signature warm
+    # wedge between bench 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))
 
     cam_data = bpy.data.cameras.new("Cam")
     cam_data.lens = 50.0
     cam = bpy.data.objects.new("Cam", cam_data)
-    cam.location = (0.3, -9.2, 2.5)
+    cam.location = (0.7, -13.0, 3.4)
     scene.collection.objects.link(cam)
     target = bpy.data.objects.new("Aim", None)
-    target.location = (0.15, 0.0, 1.35)
+    target.location = (0.0, 0.0, 2.15)
     scene.collection.objects.link(target)
     con = cam.constraints.new('TRACK_TO')
     con.target = target