diff --git a/README.md b/README.md
index 0a57365e..f7f4777b 100644
--- a/README.md
+++ b/README.md
@@ -514,7 +514,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 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>
+<a href="examples/vse-gamma-cross/"><img src="examples/vse-gamma-cross/preview.webp" alt="VSE gamma cross: a hooded grading monitor on a walnut riser beside a three-trackball control surface, its screen showing every frame of an orange-to-azure cross as two filmstrips - the GAMMA_CROSS strip on top sinking to dark grey at mid-cross, the linear CROSS strip beneath passing through violet" /></a>
 </td>
 <td valign="middle">
 
@@ -523,7 +523,7 @@ honors linking too (measured), with Cycles pinned for deterministic samples.
 The GAMMA_CROSS fade is not the naive linear mix: it blends in a gamma-0.5
 space, `((1-t)·√A + t·√B)²` with `t = (frame − start) / duration` — never 1
 inside the effect. Per-frame sample renders assert the closed form (mid dips
-0.115 below the sRGB lerp), and the AgX-default sampling trap is documented
+0.250 below the sRGB lerp), and the AgX-default sampling trap is documented
 (`view_transform = 'Standard'` is mandatory for any pixel witness).
 
 </td>
diff --git a/docs/gallery/assets/vse-gamma-cross-hero.webp b/docs/gallery/assets/vse-gamma-cross-hero.webp
index 7d3c6ccc..c66bf4d2 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/vse-gamma-cross-contact-sheet.webp b/docs/gallery/contact-sheets/vse-gamma-cross-contact-sheet.webp
index 0b04aff0..d8d2647c 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 c26ce7ee..96209585 100644
--- a/docs/gallery/index.html
+++ b/docs/gallery/index.html
@@ -673,12 +673,12 @@ <h2><a href="gltf-skin-roundtrip/">gltf-skin-roundtrip</a></h2>
       </article>
       <article class="card" data-tags="sequencer rendering">
         <a class="card-media" href="vse-gamma-cross/" tabindex="-1" aria-hidden="true">
-          <img src="assets/vse-gamma-cross-hero.webp" alt="A steel swatch board with a row of four fade chips from pink to cyan, and below it two mid-grey chips compared, one framed in orange." loading="lazy" decoding="async" />
+          <img src="assets/vse-gamma-cross-hero.webp" alt="A hooded grading monitor showing two orange-to-blue filmstrips: the gamma cross on top sinks to dark grey in the middle, while the linear cross beneath it passes through violet." loading="lazy" decoding="async" />
         </a>
         <div class="card-body">
           <h2><a href="vse-gamma-cross/">vse-gamma-cross</a></h2>
           <p class="teaches">The GAMMA_CROSS fade is not the naive linear mix: it blends in a gamma-0.5 space, so the mid-cross dips below the sRGB lerp. Tiny per-frame renders are asserted against the closed form per frame.</p>
-          <p class="witnesses"><span class="tag">witnesses</span> out = ((1-t)*sqrt(A) + t*sqrt(B))^2 with t = (frame - start) / duration, never 1 inside the effect. The mid lerp deviation is 0.115; AgX-default sampling poisons the fit (Standard is mandatory).</p>
+          <p class="witnesses"><span class="tag">witnesses</span> out = ((1-t)*sqrt(A) + t*sqrt(B))^2 with t = (frame - start) / duration, never 1 inside the effect. The mid lerp deviation is 0.250; AgX-default sampling poisons the fit (Standard is mandatory).</p>
           <a class="card-link" href="vse-gamma-cross/">View example<span class="sr-only"> vse-gamma-cross</span> <span aria-hidden="true">&rarr;</span></a>
         </div>
       </article>
diff --git a/docs/gallery/vse-gamma-cross/index.html b/docs/gallery/vse-gamma-cross/index.html
index 31953e3c..9e184562 100644
--- a/docs/gallery/vse-gamma-cross/index.html
+++ b/docs/gallery/vse-gamma-cross/index.html
@@ -16,13 +16,13 @@
   <meta property="og:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/vse-gamma-cross-hero.webp" />
   <meta property="og:image:width" content="1280" />
   <meta property="og:image:height" content="720" />
-  <meta property="og:image:alt" content="A steel swatch board with a row of four fade chips from pink to cyan, and below it two mid-grey chips compared, one framed in orange." />
+  <meta property="og:image:alt" content="A hooded grading monitor showing two orange-to-blue filmstrips: the gamma cross on top sinks to dark grey in the middle, while the linear cross beneath it passes through violet." />
   <meta property="og:site_name" content="Blender Developer Tools" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="vse-gamma-cross — Examples — Blender Developer Tools" />
   <meta name="twitter:description" content="The GAMMA_CROSS fade is not the naive linear mix: it blends in a gamma-0.5 space, so the mid-cross dips below the sRGB lerp. Tiny per-frame renders are asserted against the closed form per frame." />
   <meta name="twitter:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/vse-gamma-cross-hero.webp" />
-  <meta name="twitter:image:alt" content="A steel swatch board with a row of four fade chips from pink to cyan, and below it two mid-grey chips compared, one framed in orange." />
+  <meta name="twitter:image:alt" content="A hooded grading monitor showing two orange-to-blue filmstrips: the gamma cross on top sinks to dark grey in the middle, while the linear cross beneath it passes through violet." />
   <style>
     /* fonts are deployed by the landing build (docs/fonts/) */
     @font-face { font-family: 'Barlow Condensed'; font-weight: 600; font-display: swap;
@@ -268,22 +268,23 @@ <h1>vse-gamma-cross</h1>
     <p>The GAMMA_CROSS fade is not the naive linear mix: it blends in a gamma-0.5 space, so the mid-cross dips below the sRGB lerp. Tiny per-frame renders are asserted against the closed form per frame.</p>
   </header>
   <main id="main">
-    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: A steel swatch board with a row of four fade chips from pink to cyan, and below it two mid-grey chips compared, one framed in orange.">
-      <img src="../assets/vse-gamma-cross-hero.webp" alt="A steel swatch board with a row of four fade chips from pink to cyan, and below it two mid-grey chips compared, one framed in orange." width="1280" height="720" />
+    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: A hooded grading monitor showing two orange-to-blue filmstrips: the gamma cross on top sinks to dark grey in the middle, while the linear cross beneath it passes through violet.">
+      <img src="../assets/vse-gamma-cross-hero.webp" alt="A hooded grading monitor showing two orange-to-blue filmstrips: the gamma cross on top sinks to dark grey in the middle, while the linear cross beneath it passes through violet." 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> out = ((1-t)*sqrt(A) + t*sqrt(B))^2 with t = (frame - start) / duration, never 1 inside the effect. The mid lerp deviation is 0.115; AgX-default sampling poisons the fit (Standard is mandatory).</div>
+    <div class="callout"><span class="tag">witnesses</span> out = ((1-t)*sqrt(A) + t*sqrt(B))^2 with t = (frame - start) / duration, never 1 inside the effect. The mid lerp deviation is 0.250; AgX-default sampling poisons the fit (Standard is mandatory).</div>
     <div class="runline">
       <pre id="runCmd">blender --background --python examples/vse-gamma-cross/vse_gamma_cross.py --</pre>
       <button class="copy-btn" id="copyRun" type="button">Copy</button>
     </div>
     <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>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 signal-orange and azure 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>
-<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 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>
+<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. The endpoints are chosen to make that dip as large as a cross can: orange <code>(1.0, 0.36, 0.0)</code> and azure <code>(0.0, 0.16, 1.0)</code> have per-channel square roots summing to 1, so the gamma midpoint is the neutral <code>(0.25, 0.25, 0.25)</code> while the lerp midpoint is the violet <code>(0.5, 0.26, 0.5)</code>: <strong>0.25 darker</strong> on red and blue, the per-channel maximum. 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.71e-3) and that the mid lerp deviation is material (≥0.05; measured 0.250).</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.2490 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, 5.1 and 5.2 LTS — 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 evidence itself, mounted. All 32 frames of the cross are rendered by the sequencer and laid side by side as a filmstrip: the GAMMA_CROSS strip on top, and directly beneath it the same two strips crossed by the sequencer&#x27;s linear <code>CROSS</code> effect, frame for frame. Both filmstrips are authentic sequencer pixels shown unaltered (closest-texel sampling, emission only, Standard view) on a hooded grading monitor beside a three-ball control surface. The gamma strip sinks into a dark neutral valley at mid-cross where the linear strip passes through violet; three small warm ticks mark the t = 1/2 column. A GAMMA_CROSS that was really a lerp would make the two strips identical, so the still visibly breaks with the contract.</p>
+<p>Before shooting, the render path guards its own comparison (exit 9): every frame must fill its tile edge to edge — a 5.2 COLOR strip bakes the scene size into its width/height at creation, so strips built before the tile resolution is set letterbox into black bars (probe: in-frame spread 1.0) — and each strip&#x27;s mid frame must match its closed form, so the lower strip really is the lerp (probe: wiring GAMMA_CROSS in its place fails at 0.249).</p>
 <h2>Run</h2>
 <pre><code># Correctness check (tiny per-frame sample renders) — the CI check:
 blender --background --python vse_gamma_cross.py --
@@ -291,12 +292,12 @@ <h2>Run</h2>
 # Falsifier: GC T2 -&gt; T1. Must exit non-zero (inputs).
 blender --background --python vse_gamma_cross.py -- --swap-inputs
 
-# Also render the calibration lightbox still (EEVEE on a GPU host; cycles on GPU-less):
+# Also render the grading-monitor 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>
 <h2>Exit codes</h2>
 <p>Per-script sequential checks. <code>9</code> is a valid check code; there is no rule against it.</p>
-<div class="table-wrap"><table><thead><tr><th scope="col">Code</th><th scope="col">Meaning</th></tr></thead><tbody><tr><td>0</td><td>Success</td></tr><tr><td>1</td><td>Uncaught exception (FATAL wrapper)</td></tr><tr><td>2</td><td>argparse / usage</td></tr><tr><td>3</td><td>GC span off closed form</td></tr><tr><td>4</td><td>GC inputs are not T1 → T2 (<code>--swap-inputs</code> lands here)</td></tr><tr><td>5</td><td>Sample <code>t</code> convention drifted</td></tr><tr><td>6</td><td>Cross sample off the gamma-0.5 closed form</td></tr><tr><td>7</td><td>Mid-cross lerp deviation missing (naive mix)</td></tr><tr><td>8</td><td><code>--output</code> produced no file</td></tr></tbody></table></div>
+<div class="table-wrap"><table><thead><tr><th scope="col">Code</th><th scope="col">Meaning</th></tr></thead><tbody><tr><td>0</td><td>Success</td></tr><tr><td>1</td><td>Uncaught exception (FATAL wrapper)</td></tr><tr><td>2</td><td>argparse / usage</td></tr><tr><td>3</td><td>GC span off closed form</td></tr><tr><td>4</td><td>GC inputs are not T1 → T2 (<code>--swap-inputs</code> lands here)</td></tr><tr><td>5</td><td>Sample <code>t</code> convention drifted</td></tr><tr><td>6</td><td>Cross sample off the gamma-0.5 closed form</td></tr><tr><td>7</td><td>Mid-cross lerp deviation missing (naive mix)</td></tr><tr><td>8</td><td><code>--output</code> produced no file</td></tr><tr><td>9</td><td><code>--output</code> filmstrip guard: a frame not uniform, or a strip&#x27;s mid frame off its closed form</td></tr><tr><td>10</td><td><code>--output</code> framing violation (<code>gallery_framing</code>)</td></tr></tbody></table></div>
 <p>The <code>blender-smoke</code> workflow runs the check on Blender 5.2 LTS and 4.5 LTS (5.1 on the weekly cron, the <code>needs-5.1</code> PR label, or manual dispatch). Smoke does not pass <code>--output</code> or <code>--swap-inputs</code>.</p>
     </section>
     <section class="detail-section src">
@@ -313,11 +314,14 @@ <h2>Source</h2>
 
     out = ((1-t)*sqrt(A) + t*sqrt(B))^2,   t = (frame - start) / duration
 
-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.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.
+so the mid-cross dips below the sRGB lerp. The endpoints are chosen so the
+dip is as large as a cross can make it: signal orange (1.0, 0.36, 0.0) and
+azure (0.0, 0.16, 1.0) have per-channel square roots that sum to 1, so the
+gamma midpoint is a neutral (0.25, 0.25, 0.25) — a dark valley — while the
+lerp midpoint is a muted violet (0.5, 0.26, 0.5): 0.25 brighter on red and
+blue, the per-channel maximum (a channel crossing 1 -&gt; 0). 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.
 
 Also witnessed: ``t`` never reaches 1 inside the effect — the last frame of
 the span blends at (duration-1)/duration; B arrives only when the effect
@@ -332,7 +336,10 @@ <h2>Source</h2>
 the falsifier (``--same-axis`` in export-preset-axis).
 
 By default it runs only the correctness check (no gallery render) — the CI
-smoke check. Pass --output to also render a still:
+smoke check. Pass --output to also render a still: every frame of the cross
+rendered by the sequencer and laid side by side as a filmstrip, the
+GAMMA_CROSS strip above an authentic sequencer CROSS (the linear mix) strip,
+mounted unaltered on a grading monitor:
 
     blender --background --python vse_gamma_cross.py --                   # check only
     blender --background --python vse_gamma_cross.py -- --swap-inputs     # must fail
@@ -340,13 +347,20 @@ <h2>Source</h2>
 &quot;&quot;&quot;</span>
 <span class="k">import</span> bpy, sys, os, math, argparse, tempfile, shutil
 
+<span class="c"># Shared Layer 1 framing measurement (render path only) — see gallery_framing.py</span>
+sys.path.insert(<span class="n">0</span>, os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir))
+sys.dont_write_bytecode = <span class="k">True</span>  <span class="c"># keep examples/__pycache__ out of the repo tree</span>
+<span class="k">import</span> gallery_framing
+
 IS_5X = bpy.app.version &gt;= (<span class="n">5</span>, <span class="n">0</span>, <span class="n">0</span>)
 
-A_RGB = (<span class="n">0.85</span>, <span class="n">0.10</span>, <span class="n">0.22</span>)    <span class="c"># crimson</span>
-B_RGB = (<span class="n">0.06</span>, <span class="n">0.75</span>, <span class="n">0.80</span>)    <span class="c"># teal</span>
+<span class="c"># sqrt(A) + sqrt(B) == 1 on every channel: the gamma midpoint is the neutral</span>
+<span class="c"># 0.25 and the dip below the lerp is the per-channel maximum 0.25</span>
+A_RGB = (<span class="n">1.0</span>, <span class="n">0.36</span>, <span class="n">0.0</span>)      <span class="c"># signal orange</span>
+B_RGB = (<span class="n">0.0</span>, <span class="n">0.16</span>, <span class="n">1.0</span>)      <span class="c"># azure</span>
 SPAN = (<span class="n">1</span>, <span class="n">33</span>)                <span class="c"># 32 frames of cross</span>
 PXW, PXH = <span class="n">64</span>, <span class="n">36</span>             <span class="c"># tiny per-sample renders, CI-safe like vse-cut-list</span>
-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>
+Q_TOL = <span class="n">5e-3</span>                  <span class="c"># 2x the 8-bit quantization step + gamma-fit residual (measured 2.71e-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, plus the final</span>
@@ -380,9 +394,11 @@ <h2>Source</h2>
     <span class="k">return</span> s.frame_final_start, s.frame_final_end, s.frame_final_duration
 
 
-<span class="k">def</span> build_cross(sc, swap_inputs=<span class="k">False</span>):
+<span class="k">def</span> build_cross(sc, swap_inputs=<span class="k">False</span>, effect=<span class="s">&quot;GAMMA_CROSS&quot;</span>):
     <span class="s">&quot;&quot;&quot;The two-strip cross: T1/T2 consumed by the GAMMA_CROSS above them
-    (effect strips consume inputs only from below — vse-cut-list&#x27;s wiring).&quot;&quot;&quot;</span>
+    (effect strips consume inputs only from below — vse-cut-list&#x27;s wiring).
+    The render path rebuilds it once with effect=&quot;CROSS&quot; for the linear
+    reference strip.&quot;&quot;&quot;</span>
     sc.frame_start = SPAN[<span class="n">0</span>]
     sc.frame_end = SPAN[<span class="n">1</span>]
     se = sc.sequence_editor <span class="k">or</span> sc.sequence_editor_create()
@@ -392,7 +408,7 @@ <h2>Source</h2>
     t2 = new_effect(coll, <span class="s">&quot;T2&quot;</span>, <span class="s">&quot;COLOR&quot;</span>, <span class="n">2</span>, SPAN)
     t2.color = B_RGB
     src1, src2 = (t2, t1) <span class="k">if</span> swap_inputs <span class="k">else</span> (t1, t2)
-    gc = new_effect(coll, <span class="s">&quot;GC&quot;</span>, <span class="s">&quot;GAMMA_CROSS&quot;</span>, <span class="n">3</span>, SPAN, input1=src1, input2=src2)
+    gc = new_effect(coll, <span class="s">&quot;GC&quot;</span>, effect, <span class="n">3</span>, SPAN, input1=src1, input2=src2)
     <span class="k">return</span> gc
 
 
@@ -492,157 +508,290 @@ <h2>Source</h2>
 
 <span class="c"># ------------------------------------------------------------- gallery ---</span>
 
+<span class="c"># Filmstrip geometry: every frame of the span (t = 0 .. 31/32) rendered by</span>
+<span class="c"># the sequencer at TILE_W x TILE_H and laid side by side, unaltered.</span>
+TILE_W, TILE_H = <span class="n">24</span>, <span class="n">150</span>
+STRIP_MX, STRIP_MY, STRIP_GAP = <span class="n">24</span>, <span class="n">26</span>, <span class="n">34</span>
+FRAMES = list(range(SPAN[<span class="n">0</span>], SPAN[<span class="n">1</span>]))              <span class="c"># 32 frames, t = k/32</span>
+MID_FRAME = SPAN[<span class="n">0</span>] + (SPAN[<span class="n">1</span>] - SPAN[<span class="n">0</span>]) // <span class="n">2</span>      <span class="c"># frame 17, t = 1/2</span>
+MARK_RGB = (<span class="n">0.95</span>, <span class="n">0.80</span>, <span class="n">0.55</span>)                       <span class="c"># warm t=1/2 index ticks</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> build_bench(sc, got):
-    <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">def</span> clear_strips(sc):
+    <span class="s">&quot;&quot;&quot;Effects first: deleting a consumed input orphans-and-deletes the
+    effect (&quot;Strip &#x27;GC&#x27; not in scene&quot; otherwise).&quot;&quot;&quot;</span>
+    coll = strips_coll(sc.sequence_editor)
+    <span class="k">for</span> s <span class="k">in</span> reversed(list(coll)):
+        coll.remove(s)
+
+
+<span class="k">def</span> render_filmstrip(sc, effect, tmp):
+    <span class="s">&quot;&quot;&quot;Render every frame of the cross with `effect` wired T1 -&gt; T2 and
+    return the frames as (TILE_H, TILE_W, 4) float arrays, read straight
+    from the sequencer&#x27;s PNGs.&quot;&quot;&quot;</span>
+    <span class="k">import</span> numpy <span class="k">as</span> np
+    clear_strips(sc)
+    <span class="c"># resolution BEFORE the strips: on 5.2 a COLOR strip bakes the scene</span>
+    <span class="c"># size into its own width/height at creation, so strips built at the</span>
+    <span class="c"># check&#x27;s 64x36 would letterbox into a thin band inside a 24x150 frame</span>
+    setup_render(sc, TILE_W, TILE_H)
+    build_cross(sc, effect=effect)
+    tiles = []
+    <span class="k">for</span> f <span class="k">in</span> FRAMES:
+        path = os.path.join(tmp, <span class="s">f&quot;</span>{effect}<span class="s">_</span>{f:<span class="s">03d</span>}<span class="s">.png</span><span class="s">&quot;</span>)
+        sc.render.filepath = path
+        sc.frame_set(f)
+        bpy.ops.render.render(write_still=<span class="k">True</span>)
+        img = bpy.data.images.load(path)
+        buf = np.empty(TILE_W * TILE_H * <span class="n">4</span>, dtype=np.float32)
+        img.pixels.foreach_get(buf)
+        bpy.data.images.remove(img)
+        tiles.append(buf.reshape(TILE_H, TILE_W, <span class="n">4</span>))
+    <span class="k">return</span> tiles
+
+
+<span class="k">def</span> compose_screen(gamma_tiles, linear_tiles, path):
+    <span class="s">&quot;&quot;&quot;Lay the two filmstrips on a black screen raster: GAMMA_CROSS on top,
+    the linear CROSS directly beneath, frame for frame. The frame pixels are
+    copied verbatim; the only authored pixels are the black surround and
+    three small warm ticks marking the t = 1/2 column.&quot;&quot;&quot;</span>
+    <span class="k">import</span> numpy <span class="k">as</span> np
+    n = len(FRAMES)
+    w = <span class="n">2</span> * STRIP_MX + n * TILE_W
+    h = <span class="n">2</span> * STRIP_MY + <span class="n">2</span> * TILE_H + STRIP_GAP
+    raster = np.zeros((h, w, <span class="n">4</span>), dtype=np.float32)
+    raster[..., <span class="n">3</span>] = <span class="n">1.0</span>
+    <span class="c"># image rows run bottom-up: the linear strip sits low, gamma above it</span>
+    y_lin = STRIP_MY
+    y_gam = STRIP_MY + TILE_H + STRIP_GAP
+    <span class="k">for</span> i, (g, l) <span class="k">in</span> enumerate(zip(gamma_tiles, linear_tiles)):
+        x = STRIP_MX + i * TILE_W
+        raster[y_gam:y_gam + TILE_H, x:x + TILE_W] = g
+        raster[y_lin:y_lin + TILE_H, x:x + TILE_W] = l
+    mx = STRIP_MX + (MID_FRAME - SPAN[<span class="n">0</span>]) * TILE_W + TILE_W // <span class="n">2</span>
+    tick = (*MARK_RGB, <span class="n">1.0</span>)
+    <span class="k">for</span> y0, y1 <span class="k">in</span> ((y_gam + TILE_H + <span class="n">6</span>, h - <span class="n">6</span>),            <span class="c"># above gamma</span>
+                   (y_lin + TILE_H + <span class="n">8</span>, y_gam - <span class="n">8</span>),         <span class="c"># in the gap</span>
+                   (<span class="n">6</span>, y_lin - <span class="n">6</span>)):                         <span class="c"># below linear</span>
+        raster[y0:y1, mx - <span class="n">3</span>:mx + <span class="n">3</span>] = tick
+    img = bpy.data.images.new(<span class="s">&quot;CrossMonitor&quot;</span>, w, h, alpha=<span class="k">False</span>)
+    img.pixels.foreach_set(raster.ravel())
+    img.filepath_raw = path
+    img.file_format = <span class="s">&#x27;PNG&#x27;</span>
+    img.save()
+    <span class="k">return</span> img, w / h
+
+
+<span class="k">def</span> build_console(sc, screen_img, aspect):
+    <span class="s">&quot;&quot;&quot;A grading monitor on a machined yoke, hooded, standing on a walnut
+    riser beside a three-ball control surface. The screen is one unlit quad
+    showing the composed filmstrips with closest-texel sampling: the
+    sequencer&#x27;s pixels reach the camera exactly as it wrote them.&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
+    m = math
+
+    <span class="k">def</span> pbr(name, color, metallic, rough, spec=<span class="k">None</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 = (*color, <span class="n">1.0</span>)
+        b.inputs[<span class="s">&quot;Metallic&quot;</span>].default_value = metallic
+        b.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = rough
+        <span class="k">if</span> spec <span class="k">is</span> <span class="k">not</span> <span class="k">None</span>:
+            s = b.inputs.get(<span class="s">&quot;Specular IOR Level&quot;</span>) <span class="k">or</span> b.inputs.get(<span class="s">&quot;Specular&quot;</span>)
+            s.default_value = spec
+        <span class="k">return</span> mat
 
-    <span class="k">def</span> mat_principled(name, color, metallic, rough):
+    <span class="k">def</span> glow(name, rgb, strength):
         mat = bpy.data.materials.new(name)
         mat.use_nodes = <span class="k">True</span>
-        bsdf = mat.node_tree.nodes[<span class="s">&quot;Principled BSDF&quot;</span>]
-        bsdf.inputs[<span class="s">&quot;Base Color&quot;</span>].default_value = (*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
+        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 = strength
+        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="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>):
+    shell = pbr(<span class="s">&quot;MonitorShell&quot;</span>, (<span class="n">0.07</span>, <span class="n">0.075</span>, <span class="n">0.085</span>), <span class="n">0.55</span>, <span class="n">0.38</span>)
+    rear = pbr(<span class="s">&quot;MonitorRear&quot;</span>, (<span class="n">0.045</span>, <span class="n">0.047</span>, <span class="n">0.052</span>), <span class="n">0.3</span>, <span class="n">0.55</span>)
+    hood = pbr(<span class="s">&quot;HoodFabric&quot;</span>, (<span class="n">0.018</span>, <span class="n">0.018</span>, <span class="n">0.02</span>), <span class="n">0.0</span>, <span class="n">0.92</span>, spec=<span class="n">0.1</span>)
+    alu = pbr(<span class="s">&quot;YokeAluminium&quot;</span>, (<span class="n">0.50</span>, <span class="n">0.51</span>, <span class="n">0.54</span>), <span class="n">0.6</span>, <span class="n">0.35</span>)
+    walnut = pbr(<span class="s">&quot;RiserWalnut&quot;</span>, (<span class="n">0.19</span>, <span class="n">0.075</span>, <span class="n">0.028</span>), <span class="n">0.0</span>, <span class="n">0.55</span>, spec=<span class="n">0.25</span>)
+    panel = pbr(<span class="s">&quot;PanelAnodized&quot;</span>, (<span class="n">0.10</span>, <span class="n">0.105</span>, <span class="n">0.12</span>), <span class="n">0.7</span>, <span class="n">0.42</span>)
+    ball = pbr(<span class="s">&quot;TrackballResin&quot;</span>, (<span class="n">0.025</span>, <span class="n">0.025</span>, <span class="n">0.03</span>), <span class="n">0.0</span>, <span class="n">0.12</span>)
+    key = pbr(<span class="s">&quot;KeyCap&quot;</span>, (<span class="n">0.03</span>, <span class="n">0.03</span>, <span class="n">0.034</span>), <span class="n">0.0</span>, <span class="n">0.6</span>)
+    tally = glow(<span class="s">&quot;TallyLamp&quot;</span>, (<span class="n">1.0</span>, <span class="n">0.25</span>, <span class="n">0.08</span>), <span class="n">6.0</span>)
+    keylit = glow(<span class="s">&quot;KeyBacklight&quot;</span>, (<span class="n">0.95</span>, <span class="n">0.72</span>, <span class="n">0.42</span>), <span class="n">2.0</span>)
+
+    <span class="k">def</span> link(name, me, loc, rot=(<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>)):
+        ob = bpy.data.objects.new(name, me)
+        ob.location = loc
+        ob.rotation_euler = rot
+        sc.collection.objects.link(ob)
+        <span class="k">return</span> ob
+
+    <span class="k">def</span> rbox(name, dims, loc, mat, bevel=<span class="n">0.02</span>, rot=(<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>), seg=<span class="n">3</span>):
+        <span class="s">&quot;&quot;&quot;A box with machined, rounded edges.&quot;&quot;&quot;</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((*dims, <span class="n">1.0</span>)))
+            <span class="k">if</span> bevel &gt; <span class="n">0.0</span>:
+                bmesh.ops.bevel(bm, geom=list(bm.edges), offset=bevel,
+                                segments=seg, profile=<span class="n">0.5</span>, affect=<span class="s">&#x27;EDGES&#x27;</span>,
+                                clamp_overlap=<span class="k">True</span>)
             bm.to_mesh(me)
         <span class="k">finally</span>:
             bm.free()
         me.materials.append(mat)
-        ob = bpy.data.objects.new(name, me)
-        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">return</span> link(name, me, loc, rot)
 
-    <span class="k">def</span> bolt(x, z):
-        me = bpy.data.meshes.new(<span class="s">&quot;Bolt&quot;</span>)
+    <span class="k">def</span> cyl(name, r, depth, loc, mat, seg=<span class="n">48</span>, rot=(<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>), r2=<span class="k">None</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">6</span>, radius1=<span class="n">0.085</span>, radius2=<span class="n">0.085</span>,
-                                  depth=<span class="n">0.07</span>)
+            bmesh.ops.create_cone(bm, cap_ends=<span class="k">True</span>, cap_tris=<span class="k">False</span>, segments=seg,
+                                  radius1=r, radius2=r <span class="k">if</span> r2 <span class="k">is</span> <span class="k">None</span> <span class="k">else</span> r2,
+                                  depth=depth)
+            <span class="k">for</span> fc <span class="k">in</span> bm.faces:
+                fc.smooth = abs(fc.normal.z) &lt; <span class="n">0.5</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">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.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):
-        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>]
-    cb.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>)
-    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.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.5</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>
-        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, 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)
-
-    <span class="k">for</span> (_t, label), x <span class="k">in</span> zip(top, top_xs):
-        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):
-    scene = sc
-    build_bench(scene, got)
+        me.materials.append(mat)
+        <span class="k">return</span> link(name, me, loc, rot)
 
-    <span class="k">import</span> mathutils, bmesh
+    <span class="k">def</span> sphere(name, r, loc, mat):
+        me = bpy.data.meshes.new(name)
+        bm = bmesh.new()
+        <span class="k">try</span>:
+            bmesh.ops.create_uvsphere(bm, u_segments=<span class="n">48</span>, v_segments=<span class="n">24</span>, radius=r)
+            <span class="k">for</span> fc <span class="k">in</span> bm.faces:
+                fc.smooth = <span class="k">True</span>
+            bm.to_mesh(me)
+        <span class="k">finally</span>:
+            bm.free()
+        me.materials.append(mat)
+        <span class="k">return</span> link(name, me, loc)
+
+    <span class="c"># ---- riser: a walnut slab on a recessed aluminium plinth band</span>
+    riser_top = <span class="n">0.16</span>
+    rbox(<span class="s">&quot;Riser&quot;</span>, (<span class="n">2.90</span>, <span class="n">1.50</span>, <span class="n">0.10</span>), (<span class="n">0.0</span>, -<span class="n">0.18</span>, riser_top - <span class="n">0.05</span>), walnut, bevel=<span class="n">0.025</span>)
+    rbox(<span class="s">&quot;RiserBand&quot;</span>, (<span class="n">2.76</span>, <span class="n">1.36</span>, <span class="n">0.07</span>), (<span class="n">0.0</span>, -<span class="n">0.18</span>, <span class="n">0.035</span>), alu, bevel=<span class="n">0.01</span>)
+
+    <span class="c"># ---- monitor: screen quad sized from the composed raster&#x27;s aspect</span>
+    scr_w = <span class="n">2.30</span>
+    scr_h = scr_w / aspect
+    border, chin = <span class="n">0.06</span>, <span class="n">0.13</span>
+    body_w = scr_w + <span class="n">2</span> * border
+    body_h = scr_h + border + chin
+    body_d = <span class="n">0.12</span>
+    yoke_h = <span class="n">0.34</span>
+    body_z0 = riser_top + <span class="n">0.05</span> + yoke_h
+    body_zc = body_z0 + body_h / <span class="n">2</span>
+    scr_zc = body_z0 + chin + scr_h / <span class="n">2</span>
+    rbox(<span class="s">&quot;MonitorBody&quot;</span>, (body_w, body_d, body_h), (<span class="n">0.0</span>, <span class="n">0.0</span>, body_zc), shell, bevel=<span class="n">0.03</span>)
+    rbox(<span class="s">&quot;MonitorRear&quot;</span>, (body_w * <span class="n">0.72</span>, <span class="n">0.16</span>, body_h * <span class="n">0.72</span>),
+         (<span class="n">0.0</span>, body_d / <span class="n">2</span> + <span class="n">0.06</span>, body_zc + <span class="n">0.02</span>), rear, bevel=<span class="n">0.06</span>)
+
+    sme = bpy.data.meshes.new(<span class="s">&quot;ScreenPanel&quot;</span>)
+    bm = bmesh.new()
+    <span class="k">try</span>:
+        y = -body_d / <span class="n">2</span> - <span class="n">0.002</span>
+        q = [bm.verts.new(p) <span class="k">for</span> p <span class="k">in</span> ((-scr_w / <span class="n">2</span>, y, scr_zc - scr_h / <span class="n">2</span>),
+                                       (scr_w / <span class="n">2</span>, y, scr_zc - scr_h / <span class="n">2</span>),
+                                       (scr_w / <span class="n">2</span>, y, scr_zc + scr_h / <span class="n">2</span>),
+                                       (-scr_w / <span class="n">2</span>, y, scr_zc + scr_h / <span class="n">2</span>))]
+        uv = bm.loops.layers.uv.new(<span class="s">&quot;UVMap&quot;</span>)
+        fc = bm.faces.new(q)
+        <span class="k">for</span> li, lp <span class="k">in</span> enumerate(fc.loops):
+            lp[uv].uv = ((<span class="n">0.0</span>, <span class="n">0.0</span>), (<span class="n">1.0</span>, <span class="n">0.0</span>), (<span class="n">1.0</span>, <span class="n">1.0</span>), (<span class="n">0.0</span>, <span class="n">1.0</span>))[li]
+        bm.to_mesh(sme)
+    <span class="k">finally</span>:
+        bm.free()
+    smat = bpy.data.materials.new(<span class="s">&quot;ScreenPixels&quot;</span>)
+    smat.use_nodes = <span class="k">True</span>
+    nt = smat.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>)
+    tex = nt.nodes.new(<span class="s">&quot;ShaderNodeTexImage&quot;</span>)
+    tex.image = screen_img
+    tex.interpolation = <span class="s">&#x27;Closest&#x27;</span>   <span class="c"># no texel blending across frame seams</span>
+    tc = nt.nodes.new(<span class="s">&quot;ShaderNodeTexCoord&quot;</span>)
+    nt.links.new(tc.outputs[<span class="s">&quot;UV&quot;</span>], tex.inputs[<span class="s">&quot;Vector&quot;</span>])
+    nt.links.new(tex.outputs[<span class="s">&quot;Color&quot;</span>], em.inputs[<span class="s">&quot;Color&quot;</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>])
+    sme.materials.append(smat)
+    link(<span class="s">&quot;ScreenPanel&quot;</span>, sme, (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>))
+
+    <span class="c"># chin: tally lamp and a row of backlit function keys</span>
+    chin_z = body_z0 + chin / <span class="n">2</span>
+    front = -body_d / <span class="n">2</span>
+    rbox(<span class="s">&quot;TallyLamp&quot;</span>, (<span class="n">0.06</span>, <span class="n">0.02</span>, <span class="n">0.022</span>), (-body_w / <span class="n">2</span> + <span class="n">0.16</span>, front - <span class="n">0.004</span>, chin_z),
+         tally, bevel=<span class="n">0.004</span>)
+    <span class="k">for</span> i <span class="k">in</span> range(<span class="n">5</span>):
+        rbox(<span class="s">f&quot;</span><span class="s">ChinKey</span>{i}<span class="s">&quot;</span>, (<span class="n">0.085</span>, <span class="n">0.02</span>, <span class="n">0.03</span>),
+             (body_w / <span class="n">2</span> - <span class="n">0.20</span> - i * <span class="n">0.12</span>, front - <span class="n">0.004</span>, chin_z), key, bevel=<span class="n">0.006</span>)
+    rbox(<span class="s">&quot;ChinKeyLit&quot;</span>, (<span class="n">0.085</span>, <span class="n">0.022</span>, <span class="n">0.03</span>),
+         (body_w / <span class="n">2</span> - <span class="n">0.20</span>, front - <span class="n">0.006</span>, chin_z), keylit, bevel=<span class="n">0.006</span>)
+
+    <span class="c"># hood: top and flared side flaps shading the panel</span>
+    hood_d = <span class="n">0.30</span>
+    top_z = body_z0 + body_h
+    rbox(<span class="s">&quot;HoodTop&quot;</span>, (body_w + <span class="n">0.04</span>, hood_d, <span class="n">0.018</span>),
+         (<span class="n">0.0</span>, front - hood_d / <span class="n">2</span> + <span class="n">0.02</span>, top_z + <span class="n">0.004</span>), hood, bevel=<span class="n">0.006</span>,
+         rot=(m.radians(-<span class="n">6.0</span>), <span class="n">0.0</span>, <span class="n">0.0</span>))
+    <span class="k">for</span> sx <span class="k">in</span> (-<span class="n">1.0</span>, <span class="n">1.0</span>):
+        rbox(<span class="s">f&quot;</span><span class="s">HoodSide</span>{<span class="s">&#x27;L&#x27;</span> <span class="k">if</span> sx &lt; <span class="n">0</span> <span class="k">else</span> <span class="s">&#x27;R&#x27;</span>}<span class="s">&quot;</span>, (<span class="n">0.018</span>, hood_d, body_h - <span class="n">0.02</span>),
+             (sx * (body_w / <span class="n">2</span> + <span class="n">0.01</span>) + sx * hood_d * <span class="n">0.07</span>, front - hood_d / <span class="n">2</span> + <span class="n">0.03</span>,
+              body_zc), hood, bevel=<span class="n">0.006</span>, rot=(<span class="n">0.0</span>, <span class="n">0.0</span>, m.radians(-<span class="n">8.0</span> * sx)))
+
+    <span class="c"># yoke: foot plate, twin uprights, cross bar into the rear housing</span>
+    rbox(<span class="s">&quot;YokeFoot&quot;</span>, (<span class="n">0.95</span>, <span class="n">0.52</span>, <span class="n">0.05</span>), (<span class="n">0.0</span>, <span class="n">0.12</span>, riser_top + <span class="n">0.025</span>), alu, bevel=<span class="n">0.018</span>)
+    <span class="k">for</span> sx <span class="k">in</span> (-<span class="n">0.26</span>, <span class="n">0.26</span>):
+        rbox(<span class="s">&quot;YokeArm&quot;</span>, (<span class="n">0.07</span>, <span class="n">0.07</span>, yoke_h + <span class="n">0.22</span>),
+             (sx, <span class="n">0.17</span>, riser_top + <span class="n">0.05</span> + (yoke_h + <span class="n">0.22</span>) / <span class="n">2</span> - <span class="n">0.01</span>), alu, bevel=<span class="n">0.015</span>)
+    rbox(<span class="s">&quot;YokeBar&quot;</span>, (<span class="n">0.62</span>, <span class="n">0.07</span>, <span class="n">0.08</span>), (<span class="n">0.0</span>, <span class="n">0.17</span>, body_z0 + <span class="n">0.20</span>), alu, bevel=<span class="n">0.015</span>)
+    <span class="k">for</span> sx <span class="k">in</span> (-<span class="n">0.26</span>, <span class="n">0.26</span>):
+        cyl(<span class="s">&quot;YokeKnob&quot;</span>, <span class="n">0.055</span>, <span class="n">0.04</span>, (sx + (<span class="n">0.055</span> <span class="k">if</span> sx &gt; <span class="n">0</span> <span class="k">else</span> -<span class="n">0.055</span>), <span class="n">0.17</span>,
+                                      body_z0 + <span class="n">0.20</span>), rear,
+            rot=(<span class="n">0.0</span>, m.radians(<span class="n">90.0</span>), <span class="n">0.0</span>))
+
+    <span class="c"># control surface: a raked anodized deck with three trackballs</span>
+    deck_rot = (m.radians(<span class="n">9.0</span>), <span class="n">0.0</span>, <span class="n">0.0</span>)
+    deck_c = mathutils.Vector((<span class="n">0.0</span>, -<span class="n">0.66</span>, riser_top + <span class="n">0.055</span>))
+    rbox(<span class="s">&quot;ControlDeck&quot;</span>, (<span class="n">1.55</span>, <span class="n">0.52</span>, <span class="n">0.09</span>), tuple(deck_c), panel, bevel=<span class="n">0.02</span>,
+         rot=deck_rot)
+    tilt = mathutils.Euler(deck_rot).to_matrix()
+    deck_up = tilt @ mathutils.Vector((<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">1.0</span>))
+    <span class="k">for</span> i, bx <span class="k">in</span> enumerate((-<span class="n">0.46</span>, <span class="n">0.0</span>, <span class="n">0.46</span>)):
+        base = deck_c + tilt @ mathutils.Vector((bx, <span class="n">0.04</span>, <span class="n">0.045</span>))
+        cyl(<span class="s">f&quot;</span><span class="s">TrackRing</span>{i}<span class="s">&quot;</span>, <span class="n">0.15</span>, <span class="n">0.03</span>, tuple(base + deck_up * <span class="n">0.012</span>), alu,
+            rot=deck_rot)
+        sphere(<span class="s">f&quot;</span><span class="s">Trackball</span>{i}<span class="s">&quot;</span>, <span class="n">0.115</span>, tuple(base + deck_up * <span class="n">0.045</span>), ball)
+        cyl(<span class="s">f&quot;</span><span class="s">TrackCollar</span>{i}<span class="s">&quot;</span>, <span class="n">0.125</span>, <span class="n">0.02</span>, tuple(base + deck_up * <span class="n">0.03</span>), key,
+            rot=deck_rot)
+    <span class="k">for</span> i <span class="k">in</span> range(<span class="n">7</span>):
+        kx = -<span class="n">0.60</span> + i * <span class="n">0.2</span>
+        rbox(<span class="s">f&quot;</span><span class="s">DeckKey</span>{i}<span class="s">&quot;</span>, (<span class="n">0.12</span>, <span class="n">0.06</span>, <span class="n">0.03</span>),
+             tuple(deck_c + tilt @ mathutils.Vector((kx, -<span class="n">0.20</span>, <span class="n">0.05</span>))),
+             keylit <span class="k">if</span> i == <span class="n">3</span> <span class="k">else</span> key, bevel=<span class="n">0.008</span>, rot=deck_rot)
+
+
+<span class="k">def</span> build_stage(sc):
+    <span class="s">&quot;&quot;&quot;The house dark studio: floor, wall, world, four area lights.&quot;&quot;&quot;</span>
+    <span class="k">import</span> bmesh
+    <span class="k">import</span> mathutils
     floor_me = bpy.data.meshes.new(<span class="s">&quot;Floor&quot;</span>)
     bm = bmesh.new()
     <span class="k">try</span>:
@@ -657,64 +806,122 @@ <h2>Source</h2>
     fb.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.7</span>
     floor_me.materials.append(fmat)
     floor = bpy.data.objects.new(<span class="s">&quot;Floor&quot;</span>, floor_me)
-    scene.collection.objects.link(floor)
+    sc.collection.objects.link(floor)
     wall = bpy.data.objects.new(<span class="s">&quot;Wall&quot;</span>, floor_me.copy())
-    wall.location = (<span class="n">0.0</span>, <span class="n">9.0</span>, <span class="n">0.0</span>)
+    wall.location = (<span class="n">0.0</span>, <span class="n">8.0</span>, <span class="n">0.0</span>)
     wall.rotation_euler = (math.radians(<span class="n">90</span>), <span class="n">0.0</span>, <span class="n">0.0</span>)
-    scene.collection.objects.link(wall)
+    sc.collection.objects.link(wall)
 
     world = bpy.data.worlds.new(<span class="s">&quot;World&quot;</span>)
-    world.use_nodes = <span class="k">True</span>
+    <span class="k">if</span> world.node_tree <span class="k">is</span> <span class="k">None</span>:  <span class="c"># 5.x worlds ship with nodes; 4.x needs this</span>
+        world.use_nodes = <span class="k">True</span>
     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
+    sc.world = world
 
     <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
+        ld.energy = energy
+        ld.size = size
+        ld.color = col
         ob = bpy.data.objects.new(name, ld)
         ob.location = loc
         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, and the signature warm</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.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">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.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
-    scene.camera = cam
-
-    scene.render.engine = <span class="s">&#x27;CYCLES&#x27;</span> <span class="k">if</span> engine == <span class="s">&#x27;cycles&#x27;</span> <span class="k">else</span> eevee_engine_id()
-    <span class="k">if</span> engine == <span class="s">&#x27;cycles&#x27;</span>:
-        scene.cycles.samples = <span class="n">32</span>
-    <span class="k">else</span>:
-        <span class="k">try</span>:
-            scene.eevee.taa_render_samples = <span class="n">64</span>
-        <span class="k">except</span> AttributeError:
-            <span class="k">pass</span>
-    scene.render.resolution_x = <span class="n">1280</span>
-    scene.render.resolution_y = <span class="n">720</span>
-    scene.render.resolution_percentage = <span class="n">100</span>
-    scene.render.image_settings.file_format = <span class="s">&#x27;PNG&#x27;</span>
-    scene.render.filepath = path
-    <span class="c"># Standard keeps the swatch colors true (docs/VISUAL-STYLE.md)</span>
-    scene.view_settings.view_transform = <span class="s">&#x27;Standard&#x27;</span>
-    bpy.ops.render.render(write_still=<span class="k">True</span>)
-    <span class="k">return</span> os.path.exists(path) <span class="k">and</span> os.path.getsize(path) &gt; <span class="n">0</span>
+        sc.collection.objects.link(ob)
+
+    <span class="c"># warm shaped key upper left, faint cool fill, cool rim, and the warm</span>
+    <span class="c"># wedge between console and wall raking a pool onto the backdrop</span>
+    light(<span class="s">&quot;Key&quot;</span>, (-<span class="n">4.0</span>, -<span class="n">5.0</span>, <span class="n">6.0</span>), <span class="n">520.0</span>, <span class="n">4.5</span>, (<span class="n">1.0</span>, <span class="n">0.96</span>, <span class="n">0.9</span>), (<span class="n">0.0</span>, -<span class="n">0.3</span>, <span class="n">0.8</span>))
+    light(<span class="s">&quot;Fill&quot;</span>, (<span class="n">5.5</span>, -<span class="n">4.0</span>, <span class="n">2.5</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.0</span>, <span class="n">0.0</span>, <span class="n">1.0</span>))
+    light(<span class="s">&quot;Rim&quot;</span>, (<span class="n">0.5</span>, <span class="n">4.0</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">0.0</span>, <span class="n">0.2</span>, <span class="n">1.4</span>))
+    light(<span class="s">&quot;Wedge&quot;</span>, (<span class="n">1.0</span>, <span class="n">3.2</span>, <span class="n">4.4</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">1.5</span>, <span class="n">8.0</span>, <span class="n">1.8</span>))
+
+
+<span class="k">def</span> render_still(sc, path, engine):
+    <span class="s">&quot;&quot;&quot;Render both filmstrips from the sequencer, guard the linear reference,
+    then shoot the console with those exact pixels on its screen.&quot;&quot;&quot;</span>
+    tmp = tempfile.mkdtemp(prefix=<span class="s">&quot;vse_gamma_still_&quot;</span>)
+    <span class="k">try</span>:
+        gamma_tiles = render_filmstrip(sc, <span class="s">&quot;GAMMA_CROSS&quot;</span>, tmp)
+        linear_tiles = render_filmstrip(sc, <span class="s">&quot;CROSS&quot;</span>, tmp)
+        clear_strips(sc)
+        <span class="c"># the lower strip is only a fair comparison if it IS the lerp: guard</span>
+        <span class="c"># the sequencer CROSS at t = 1/2 against (1-t)*A + t*B</span>
+        k_mid = MID_FRAME - SPAN[<span class="n">0</span>]
+        cy, cx = TILE_H // <span class="n">2</span>, TILE_W // <span class="n">2</span>
+        lin_mid = linear_tiles[k_mid][cy, cx, :<span class="n">3</span>]
+        gam_mid = gamma_tiles[k_mid][cy, cx, :<span class="n">3</span>]
+        lin_err = max(abs(float(lin_mid[k]) - 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>))
+        gam_err = max(abs(float(gam_mid[k]) - closed_form(<span class="n">0.5</span>, k)) <span class="k">for</span> k <span class="k">in</span> range(<span class="n">3</span>))
+        print(<span class="s">f&quot;</span><span class="s">filmstrip mid: gamma </span>{tuple(round(float(v), <span class="n">3</span>) <span class="k">for</span> v <span class="k">in</span> gam_mid)}<span class="s"> </span><span class="s">&quot;</span>
+              <span class="s">f&quot;</span><span class="s">(err </span>{gam_err:<span class="s">.2e</span>}<span class="s">), linear </span>{tuple(round(float(v), <span class="n">3</span>) <span class="k">for</span> v <span class="k">in</span> lin_mid)}<span class="s"> </span><span class="s">&quot;</span>
+              <span class="s">f&quot;</span><span class="s">(err </span>{lin_err:<span class="s">.2e</span>}<span class="s">)</span><span class="s">&quot;</span>)
+        <span class="c"># every frame must fill its tile edge to edge (a letterboxed COLOR</span>
+        <span class="c"># strip would paint black bars into the strip and fake a dip)</span>
+        spread = max(float((t[..., :<span class="n">3</span>].max(axis=(<span class="n">0</span>, <span class="n">1</span>)) - t[..., :<span class="n">3</span>].min(axis=(<span class="n">0</span>, <span class="n">1</span>))).max())
+                     <span class="k">for</span> t <span class="k">in</span> gamma_tiles + linear_tiles)
+        print(<span class="s">f&quot;</span><span class="s">filmstrip frames uniform: max in-frame spread </span>{spread:<span class="s">.2e</span>}<span class="s">&quot;</span>)
+        <span class="k">if</span> spread &gt; Q_TOL:
+            print(<span class="s">f&quot;</span><span class="s">ERROR: a filmstrip frame is not uniform (spread </span>{spread:<span class="s">.4f</span>}<span class="s">)</span><span class="s">&quot;</span>,
+                  file=sys.stderr)
+            <span class="k">return</span> <span class="n">9</span>
+        <span class="k">if</span> lin_err &gt; Q_TOL <span class="k">or</span> gam_err &gt; Q_TOL:
+            print(<span class="s">f&quot;</span><span class="s">ERROR: filmstrip mid off its closed form (linear </span>{lin_err:<span class="s">.4f</span>}<span class="s">, </span><span class="s">&quot;</span>
+                  <span class="s">f&quot;</span><span class="s">gamma </span>{gam_err:<span class="s">.4f</span>}<span class="s">, tol </span>{Q_TOL}<span class="s">) — the comparison would lie</span><span class="s">&quot;</span>,
+                  file=sys.stderr)
+            <span class="k">return</span> <span class="n">9</span>
+
+        screen_img, aspect = compose_screen(
+            gamma_tiles, linear_tiles, os.path.join(tmp, <span class="s">&quot;monitor.png&quot;</span>))
+        screen_img.pack()   <span class="c"># the raster outlives the temp dir</span>
+
+        build_stage(sc)
+        build_console(sc, screen_img, aspect)
+
+        cam_data = bpy.data.cameras.new(<span class="s">&quot;Cam&quot;</span>)
+        cam_data.lens = <span class="n">50.0</span>
+        cam = bpy.data.objects.new(<span class="s">&quot;Cam&quot;</span>, cam_data)
+        cam.location = (<span class="n">1.55</span>, -<span class="n">6.2</span>, <span class="n">1.55</span>)
+        sc.collection.objects.link(cam)
+        aim = bpy.data.objects.new(<span class="s">&quot;Aim&quot;</span>, <span class="k">None</span>)
+        aim.location = (<span class="n">0.05</span>, -<span class="n">0.2</span>, <span class="n">0.86</span>)
+        sc.collection.objects.link(aim)
+        con = cam.constraints.new(<span class="s">&#x27;TRACK_TO&#x27;</span>)
+        con.target = aim
+        sc.camera = cam
+
+        sc.render.engine = <span class="s">&#x27;CYCLES&#x27;</span> <span class="k">if</span> engine == <span class="s">&#x27;cycles&#x27;</span> <span class="k">else</span> eevee_engine_id()
+        <span class="k">if</span> engine == <span class="s">&#x27;cycles&#x27;</span>:
+            sc.cycles.samples = <span class="n">64</span>
+            sc.cycles.use_denoising = <span class="k">True</span>
+        <span class="k">else</span>:
+            <span class="k">try</span>:
+                sc.eevee.taa_render_samples = <span class="n">64</span>
+            <span class="k">except</span> AttributeError:
+                <span class="k">pass</span>
+        sc.render.resolution_x = <span class="n">1280</span>
+        sc.render.resolution_y = <span class="n">720</span>
+        sc.render.resolution_percentage = <span class="n">100</span>
+        sc.render.image_settings.file_format = <span class="s">&#x27;PNG&#x27;</span>
+        sc.render.filepath = path
+        <span class="c"># Standard keeps the mounted sequencer pixels exact (docs/VISUAL-STYLE.md)</span>
+        sc.view_settings.view_transform = <span class="s">&#x27;Standard&#x27;</span>
+
+        <span class="c"># Layer 1 framing gate on the console — exit 10 before the beauty pass</span>
+        stage = [o <span class="k">for</span> o <span class="k">in</span> sc.objects <span class="k">if</span> o.name <span class="k">in</span> (<span class="s">&quot;Floor&quot;</span>, <span class="s">&quot;Wall&quot;</span>)]
+        hero = [o <span class="k">for</span> o <span class="k">in</span> sc.objects
+                <span class="k">if</span> o.type <span class="k">in</span> gallery_framing._RENDER_TYPES <span class="k">and</span> o <span class="k">not</span> <span class="k">in</span> stage]
+        fcode = gallery_framing.check_framing(sc, cam, hero=hero, elements=hero,
+                                              stage=stage)
+        <span class="k">if</span> fcode:
+            <span class="k">return</span> fcode
+        bpy.ops.render.render(write_still=<span class="k">True</span>)
+    <span class="k">finally</span>:
+        shutil.rmtree(tmp, ignore_errors=<span class="k">True</span>)
+    <span class="k">if</span> <span class="k">not</span> (os.path.exists(path) <span class="k">and</span> os.path.getsize(path) &gt; <span class="n">0</span>):
+        print(<span class="s">&quot;ERROR: render produced no file&quot;</span>, file=sys.stderr)
+        <span class="k">return</span> <span class="n">8</span>
+    <span class="k">return</span> <span class="n">0</span>
 
 
 <span class="k">def</span> main():
@@ -735,23 +942,9 @@ <h2>Source</h2>
         <span class="k">return</span> code
 
     <span class="k">if</span> args.output:
-        <span class="c"># re-sample the authentic cross colors for the bench panels</span>
-        setup_render(sc, PXW, PXH)
-        tmp = tempfile.mkdtemp(prefix=<span class="s">&quot;vse_gamma_still_&quot;</span>)
-        <span class="k">try</span>:
-            got = sample_colors(sc, [f <span class="k">for</span> f, _t <span class="k">in</span> SAMPLES], tmp)
-        <span class="k">finally</span>:
-            shutil.rmtree(tmp, ignore_errors=<span class="k">True</span>)
-        <span class="c"># the bench is a 3D scene: clear the timeline or the sequencer</span>
-        <span class="c"># composites the last cross frame over everything (a full-teal</span>
-        <span class="c"># still). Effects first: deleting inputs orphans-and-deletes the</span>
-        <span class="c"># effect (&quot;Strip &#x27;GC&#x27; not in scene&quot; otherwise)</span>
-        coll = strips_coll(sc.sequence_editor)
-        <span class="k">for</span> s <span class="k">in</span> reversed(list(coll)):
-            coll.remove(s)
-        <span class="k">if</span> <span class="k">not</span> render_still(sc, got, os.path.abspath(args.output), args.engine):
-            print(<span class="s">&quot;ERROR: render produced no file&quot;</span>, file=sys.stderr)
-            <span class="k">return</span> <span class="n">8</span>
+        code = render_still(sc, os.path.abspath(args.output), args.engine)
+        <span class="k">if</span> code:
+            <span class="k">return</span> code
         print(<span class="s">f&quot;</span><span class="s">rendered still </span>{args.output}<span class="s">&quot;</span>)
 
     print(<span class="s">&quot;vse-gamma-cross OK&quot;</span>)
@@ -768,7 +961,7 @@ <h2>Source</h2>
   </main>
   <dialog class="lightbox" id="lightbox" aria-label="Full-size render">
     <button class="lightbox-close" type="button" autofocus>Close</button>
-    <img src="../assets/vse-gamma-cross-hero.webp" alt="A steel swatch board with a row of four fade chips from pink to cyan, and below it two mid-grey chips compared, one framed in orange." />
+    <img src="../assets/vse-gamma-cross-hero.webp" alt="A hooded grading monitor showing two orange-to-blue filmstrips: the gamma cross on top sinks to dark grey in the middle, while the linear cross beneath it passes through violet." />
   </dialog>
   <footer>
     <div class="statusbar">
diff --git a/examples/gallery.json b/examples/gallery.json
index 46f291a7..36e021d0 100644
--- a/examples/gallery.json
+++ b/examples/gallery.json
@@ -406,8 +406,8 @@
       "name": "vse-gamma-cross",
       "dir": "examples/vse-gamma-cross",
       "teaches": "The GAMMA_CROSS fade is not the naive linear mix: it blends in a gamma-0.5 space, so the mid-cross dips below the sRGB lerp. Tiny per-frame renders are asserted against the closed form per frame.",
-      "alt": "A steel swatch board with a row of four fade chips from pink to cyan, and below it two mid-grey chips compared, one framed in orange.",
-      "witnessesFix": "out = ((1-t)*sqrt(A) + t*sqrt(B))^2 with t = (frame - start) / duration, never 1 inside the effect. The mid lerp deviation is 0.115; AgX-default sampling poisons the fit (Standard is mandatory).",
+      "alt": "A hooded grading monitor showing two orange-to-blue filmstrips: the gamma cross on top sinks to dark grey in the middle, while the linear cross beneath it passes through violet.",
+      "witnessesFix": "out = ((1-t)*sqrt(A) + t*sqrt(B))^2 with t = (frame - start) / duration, never 1 inside the effect. The mid lerp deviation is 0.250; AgX-default sampling poisons the fit (Standard is mandatory).",
       "hero": "docs/gallery/assets/vse-gamma-cross-hero.webp",
       "preview": "examples/vse-gamma-cross/preview.webp",
       "tags": [
diff --git a/examples/vse-gamma-cross/README.md b/examples/vse-gamma-cross/README.md
index e75f6593..0bcb3f80 100644
--- a/examples/vse-gamma-cross/README.md
+++ b/examples/vse-gamma-cross/README.md
@@ -1,20 +1,23 @@
 # VSE GAMMA_CROSS Blend Curve
 
 A runnable follow-up to [`vse-cut-list`](../vse-cut-list/): the check renders
-tiny frames across a GAMMA_CROSS between crimson and teal strips and asserts
-every sample against the fade's actual math — because AI-generated sequencer
-code assumes the cross is the naive linear mix, and it is not.
+tiny frames across a GAMMA_CROSS between signal-orange and azure strips and
+asserts every sample against the fade's actual math — because AI-generated
+sequencer 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.
 
 - **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
+  `((1-t)·√A + t·√B)²` — the mid-cross dips below the sRGB lerp. The
+  endpoints are chosen to make that dip as large as a cross can: orange
+  `(1.0, 0.36, 0.0)` and azure `(0.0, 0.16, 1.0)` have per-channel square
+  roots summing to 1, so the gamma midpoint is the neutral
+  `(0.25, 0.25, 0.25)` while the lerp midpoint is the violet
+  `(0.5, 0.26, 0.5)`: **0.25 darker** on red and blue, the per-channel
+  maximum. 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).
+  (2× the 8-bit quantization step + fit residual; measured 2.71e-3) and that
+  the mid lerp deviation is material (≥0.05; measured 0.250).
 - **`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,
@@ -29,22 +32,31 @@ code assumes the cross is the naive linear mix, and it is not.
   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
+expectation (exit 6, deviation 0.2490 at mid), the endpoint-inclusive t
 convention (exit 5), and swapped cross inputs (exit 4, `input1=T2`).
 
-**Version witness:** the blend math is identical on Blender 4.5 LTS and 5.1 —
-every sample matches to the quantization step. The creation contract from
+**Version witness:** the blend math is identical on Blender 4.5 LTS, 5.1 and
+5.2 LTS — 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 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.
+The render is the evidence itself, mounted. All 32 frames of the cross are
+rendered by the sequencer and laid side by side as a filmstrip: the
+GAMMA_CROSS strip on top, and directly beneath it the same two strips
+crossed by the sequencer's linear `CROSS` effect, frame for frame. Both
+filmstrips are authentic sequencer pixels shown unaltered (closest-texel
+sampling, emission only, Standard view) on a hooded grading monitor beside a
+three-ball control surface. The gamma strip sinks into a dark neutral valley
+at mid-cross where the linear strip passes through violet; three small warm
+ticks mark the t = 1/2 column. A GAMMA_CROSS that was really a lerp would
+make the two strips identical, so the still visibly breaks with the contract.
+
+Before shooting, the render path guards its own comparison (exit 9): every
+frame must fill its tile edge to edge — a 5.2 COLOR strip bakes the scene
+size into its width/height at creation, so strips built before the tile
+resolution is set letterbox into black bars (probe: in-frame spread 1.0) —
+and each strip's mid frame must match its closed form, so the lower strip
+really is the lerp (probe: wiring GAMMA_CROSS in its place fails at 0.249).
 
 ## Run
 
@@ -55,7 +67,7 @@ blender --background --python vse_gamma_cross.py --
 # Falsifier: GC T2 -> T1. Must exit non-zero (inputs).
 blender --background --python vse_gamma_cross.py -- --swap-inputs
 
-# Also render the calibration lightbox still (EEVEE on a GPU host; cycles on GPU-less):
+# Also render the grading-monitor 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
 ```
@@ -76,6 +88,8 @@ against it.
 | 6 | Cross sample off the gamma-0.5 closed form |
 | 7 | Mid-cross lerp deviation missing (naive mix) |
 | 8 | `--output` produced no file |
+| 9 | `--output` filmstrip guard: a frame not uniform, or a strip's mid frame off its closed form |
+| 10 | `--output` framing violation (`gallery_framing`) |
 
 The `blender-smoke` workflow runs the check on Blender 5.2 LTS and 4.5 LTS
 (5.1 on the weekly cron, the `needs-5.1` PR label, or manual dispatch).
diff --git a/examples/vse-gamma-cross/preview.webp b/examples/vse-gamma-cross/preview.webp
index b6bc58b0..48b8e22e 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 1615e494..ad6c6e38 100644
--- a/examples/vse-gamma-cross/vse_gamma_cross.py
+++ b/examples/vse-gamma-cross/vse_gamma_cross.py
@@ -6,11 +6,14 @@
 
     out = ((1-t)*sqrt(A) + t*sqrt(B))^2,   t = (frame - start) / duration
 
-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.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.
+so the mid-cross dips below the sRGB lerp. The endpoints are chosen so the
+dip is as large as a cross can make it: signal orange (1.0, 0.36, 0.0) and
+azure (0.0, 0.16, 1.0) have per-channel square roots that sum to 1, so the
+gamma midpoint is a neutral (0.25, 0.25, 0.25) — a dark valley — while the
+lerp midpoint is a muted violet (0.5, 0.26, 0.5): 0.25 brighter on red and
+blue, the per-channel maximum (a channel crossing 1 -> 0). 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.
 
 Also witnessed: ``t`` never reaches 1 inside the effect — the last frame of
 the span blends at (duration-1)/duration; B arrives only when the effect
@@ -25,7 +28,10 @@
 the falsifier (``--same-axis`` in export-preset-axis).
 
 By default it runs only the correctness check (no gallery render) — the CI
-smoke check. Pass --output to also render a still:
+smoke check. Pass --output to also render a still: every frame of the cross
+rendered by the sequencer and laid side by side as a filmstrip, the
+GAMMA_CROSS strip above an authentic sequencer CROSS (the linear mix) strip,
+mounted unaltered on a grading monitor:
 
     blender --background --python vse_gamma_cross.py --                   # check only
     blender --background --python vse_gamma_cross.py -- --swap-inputs     # must fail
@@ -33,13 +39,20 @@
 """
 import bpy, sys, os, math, argparse, tempfile, shutil
 
+# Shared Layer 1 framing measurement (render path only) — see gallery_framing.py
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir))
+sys.dont_write_bytecode = True  # keep examples/__pycache__ out of the repo tree
+import gallery_framing
+
 IS_5X = bpy.app.version >= (5, 0, 0)
 
-A_RGB = (0.85, 0.10, 0.22)    # crimson
-B_RGB = (0.06, 0.75, 0.80)    # teal
+# sqrt(A) + sqrt(B) == 1 on every channel: the gamma midpoint is the neutral
+# 0.25 and the dip below the lerp is the per-channel maximum 0.25
+A_RGB = (1.0, 0.36, 0.0)      # signal orange
+B_RGB = (0.0, 0.16, 1.0)      # azure
 SPAN = (1, 33)                # 32 frames of cross
 PXW, PXH = 64, 36             # tiny per-sample renders, CI-safe like vse-cut-list
-Q_TOL = 5e-3                  # 2x the 8-bit quantization step + gamma-fit residual (measured 2.93e-3)
+Q_TOL = 5e-3                  # 2x the 8-bit quantization step + gamma-fit residual (measured 2.71e-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, plus the final
@@ -73,9 +86,11 @@ def strip_span(s):
     return s.frame_final_start, s.frame_final_end, s.frame_final_duration
 
 
-def build_cross(sc, swap_inputs=False):
+def build_cross(sc, swap_inputs=False, effect="GAMMA_CROSS"):
     """The two-strip cross: T1/T2 consumed by the GAMMA_CROSS above them
-    (effect strips consume inputs only from below — vse-cut-list's wiring)."""
+    (effect strips consume inputs only from below — vse-cut-list's wiring).
+    The render path rebuilds it once with effect="CROSS" for the linear
+    reference strip."""
     sc.frame_start = SPAN[0]
     sc.frame_end = SPAN[1]
     se = sc.sequence_editor or sc.sequence_editor_create()
@@ -85,7 +100,7 @@ def build_cross(sc, swap_inputs=False):
     t2 = new_effect(coll, "T2", "COLOR", 2, SPAN)
     t2.color = B_RGB
     src1, src2 = (t2, t1) if swap_inputs else (t1, t2)
-    gc = new_effect(coll, "GC", "GAMMA_CROSS", 3, SPAN, input1=src1, input2=src2)
+    gc = new_effect(coll, "GC", effect, 3, SPAN, input1=src1, input2=src2)
     return gc
 
 
@@ -185,157 +200,290 @@ def check(sc, gc):
 
 # ------------------------------------------------------------- gallery ---
 
+# Filmstrip geometry: every frame of the span (t = 0 .. 31/32) rendered by
+# the sequencer at TILE_W x TILE_H and laid side by side, unaltered.
+TILE_W, TILE_H = 24, 150
+STRIP_MX, STRIP_MY, STRIP_GAP = 24, 26, 34
+FRAMES = list(range(SPAN[0], SPAN[1]))              # 32 frames, t = k/32
+MID_FRAME = SPAN[0] + (SPAN[1] - SPAN[0]) // 2      # frame 17, t = 1/2
+MARK_RGB = (0.95, 0.80, 0.55)                       # warm t=1/2 index ticks
+
+
 def eevee_engine_id():
     return 'BLENDER_EEVEE' if bpy.app.version >= (5, 0, 0) else 'BLENDER_EEVEE_NEXT'
 
 
-def build_bench(sc, got):
-    """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."""
+def clear_strips(sc):
+    """Effects first: deleting a consumed input orphans-and-deletes the
+    effect ("Strip 'GC' not in scene" otherwise)."""
+    coll = strips_coll(sc.sequence_editor)
+    for s in reversed(list(coll)):
+        coll.remove(s)
+
+
+def render_filmstrip(sc, effect, tmp):
+    """Render every frame of the cross with `effect` wired T1 -> T2 and
+    return the frames as (TILE_H, TILE_W, 4) float arrays, read straight
+    from the sequencer's PNGs."""
+    import numpy as np
+    clear_strips(sc)
+    # resolution BEFORE the strips: on 5.2 a COLOR strip bakes the scene
+    # size into its own width/height at creation, so strips built at the
+    # check's 64x36 would letterbox into a thin band inside a 24x150 frame
+    setup_render(sc, TILE_W, TILE_H)
+    build_cross(sc, effect=effect)
+    tiles = []
+    for f in FRAMES:
+        path = os.path.join(tmp, f"{effect}_{f:03d}.png")
+        sc.render.filepath = path
+        sc.frame_set(f)
+        bpy.ops.render.render(write_still=True)
+        img = bpy.data.images.load(path)
+        buf = np.empty(TILE_W * TILE_H * 4, dtype=np.float32)
+        img.pixels.foreach_get(buf)
+        bpy.data.images.remove(img)
+        tiles.append(buf.reshape(TILE_H, TILE_W, 4))
+    return tiles
+
+
+def compose_screen(gamma_tiles, linear_tiles, path):
+    """Lay the two filmstrips on a black screen raster: GAMMA_CROSS on top,
+    the linear CROSS directly beneath, frame for frame. The frame pixels are
+    copied verbatim; the only authored pixels are the black surround and
+    three small warm ticks marking the t = 1/2 column."""
+    import numpy as np
+    n = len(FRAMES)
+    w = 2 * STRIP_MX + n * TILE_W
+    h = 2 * STRIP_MY + 2 * TILE_H + STRIP_GAP
+    raster = np.zeros((h, w, 4), dtype=np.float32)
+    raster[..., 3] = 1.0
+    # image rows run bottom-up: the linear strip sits low, gamma above it
+    y_lin = STRIP_MY
+    y_gam = STRIP_MY + TILE_H + STRIP_GAP
+    for i, (g, l) in enumerate(zip(gamma_tiles, linear_tiles)):
+        x = STRIP_MX + i * TILE_W
+        raster[y_gam:y_gam + TILE_H, x:x + TILE_W] = g
+        raster[y_lin:y_lin + TILE_H, x:x + TILE_W] = l
+    mx = STRIP_MX + (MID_FRAME - SPAN[0]) * TILE_W + TILE_W // 2
+    tick = (*MARK_RGB, 1.0)
+    for y0, y1 in ((y_gam + TILE_H + 6, h - 6),            # above gamma
+                   (y_lin + TILE_H + 8, y_gam - 8),         # in the gap
+                   (6, y_lin - 6)):                         # below linear
+        raster[y0:y1, mx - 3:mx + 3] = tick
+    img = bpy.data.images.new("CrossMonitor", w, h, alpha=False)
+    img.pixels.foreach_set(raster.ravel())
+    img.filepath_raw = path
+    img.file_format = 'PNG'
+    img.save()
+    return img, w / h
+
+
+def build_console(sc, screen_img, aspect):
+    """A grading monitor on a machined yoke, hooded, standing on a walnut
+    riser beside a three-ball control surface. The screen is one unlit quad
+    showing the composed filmstrips with closest-texel sampling: the
+    sequencer's pixels reach the camera exactly as it wrote them."""
     import bmesh
     import mathutils
-    import math as m
+    m = math
+
+    def pbr(name, color, metallic, rough, spec=None):
+        mat = bpy.data.materials.new(name)
+        mat.use_nodes = True
+        b = mat.node_tree.nodes["Principled BSDF"]
+        b.inputs["Base Color"].default_value = (*color, 1.0)
+        b.inputs["Metallic"].default_value = metallic
+        b.inputs["Roughness"].default_value = rough
+        if spec is not None:
+            s = b.inputs.get("Specular IOR Level") or b.inputs.get("Specular")
+            s.default_value = spec
+        return mat
 
-    def mat_principled(name, color, metallic, rough):
+    def glow(name, rgb, strength):
         mat = bpy.data.materials.new(name)
         mat.use_nodes = True
-        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
+        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 = strength
+        nt.links.new(em.outputs["Emission"], out.inputs["Surface"])
         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):
+    shell = pbr("MonitorShell", (0.07, 0.075, 0.085), 0.55, 0.38)
+    rear = pbr("MonitorRear", (0.045, 0.047, 0.052), 0.3, 0.55)
+    hood = pbr("HoodFabric", (0.018, 0.018, 0.02), 0.0, 0.92, spec=0.1)
+    alu = pbr("YokeAluminium", (0.50, 0.51, 0.54), 0.6, 0.35)
+    walnut = pbr("RiserWalnut", (0.19, 0.075, 0.028), 0.0, 0.55, spec=0.25)
+    panel = pbr("PanelAnodized", (0.10, 0.105, 0.12), 0.7, 0.42)
+    ball = pbr("TrackballResin", (0.025, 0.025, 0.03), 0.0, 0.12)
+    key = pbr("KeyCap", (0.03, 0.03, 0.034), 0.0, 0.6)
+    tally = glow("TallyLamp", (1.0, 0.25, 0.08), 6.0)
+    keylit = glow("KeyBacklight", (0.95, 0.72, 0.42), 2.0)
+
+    def link(name, me, loc, rot=(0.0, 0.0, 0.0)):
+        ob = bpy.data.objects.new(name, me)
+        ob.location = loc
+        ob.rotation_euler = rot
+        sc.collection.objects.link(ob)
+        return ob
+
+    def rbox(name, dims, loc, mat, bevel=0.02, rot=(0.0, 0.0, 0.0), seg=3):
+        """A box with machined, rounded edges."""
         me = bpy.data.meshes.new(name)
         bm = bmesh.new()
         try:
             bmesh.ops.create_cube(bm, size=1.0,
                                   matrix=mathutils.Matrix.Diagonal((*dims, 1.0)))
+            if bevel > 0.0:
+                bmesh.ops.bevel(bm, geom=list(bm.edges), offset=bevel,
+                                segments=seg, profile=0.5, affect='EDGES',
+                                clamp_overlap=True)
             bm.to_mesh(me)
         finally:
             bm.free()
         me.materials.append(mat)
-        ob = bpy.data.objects.new(name, me)
-        ob.location = loc
-        ob.rotation_euler = (rot_x, 0.0, 0.0)
-        sc.collection.objects.link(ob)
+        return link(name, me, loc, rot)
 
-    def bolt(x, z):
-        me = bpy.data.meshes.new("Bolt")
+    def cyl(name, r, depth, loc, mat, seg=48, rot=(0.0, 0.0, 0.0), r2=None):
+        me = bpy.data.meshes.new(name)
         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)
+            bmesh.ops.create_cone(bm, cap_ends=True, cap_tris=False, segments=seg,
+                                  radius1=r, radius2=r if r2 is None else r2,
+                                  depth=depth)
+            for fc in bm.faces:
+                fc.smooth = abs(fc.normal.z) < 0.5
             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)
-
-    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.625 + 1.75 * i for i in range(4)]
-    for (t, _label), x in zip(top, top_xs):
-        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"]
-    cb.inputs["Base Color"].default_value = (0.42, 0.44, 0.48, 1.0)
-    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.38, 0.40, 0.45, 1.0)
-    cb.inputs["Emission Strength"].default_value = 0.5
-
-    def caption(text, x, z, size, y=-0.03):
-        cu = bpy.data.curves.new("Caption", 'FONT')
-        cu.body = text
-        cu.align_x = 'CENTER'
-        cu.size = size
-        cu.extrude = 0.004
-        ob = bpy.data.objects.new("Caption", cu)
-        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)
-
-    for (_t, label), x in zip(top, top_xs):
-        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):
-    scene = sc
-    build_bench(scene, got)
+        me.materials.append(mat)
+        return link(name, me, loc, rot)
 
-    import mathutils, bmesh
+    def sphere(name, r, loc, mat):
+        me = bpy.data.meshes.new(name)
+        bm = bmesh.new()
+        try:
+            bmesh.ops.create_uvsphere(bm, u_segments=48, v_segments=24, radius=r)
+            for fc in bm.faces:
+                fc.smooth = True
+            bm.to_mesh(me)
+        finally:
+            bm.free()
+        me.materials.append(mat)
+        return link(name, me, loc)
+
+    # ---- riser: a walnut slab on a recessed aluminium plinth band
+    riser_top = 0.16
+    rbox("Riser", (2.90, 1.50, 0.10), (0.0, -0.18, riser_top - 0.05), walnut, bevel=0.025)
+    rbox("RiserBand", (2.76, 1.36, 0.07), (0.0, -0.18, 0.035), alu, bevel=0.01)
+
+    # ---- monitor: screen quad sized from the composed raster's aspect
+    scr_w = 2.30
+    scr_h = scr_w / aspect
+    border, chin = 0.06, 0.13
+    body_w = scr_w + 2 * border
+    body_h = scr_h + border + chin
+    body_d = 0.12
+    yoke_h = 0.34
+    body_z0 = riser_top + 0.05 + yoke_h
+    body_zc = body_z0 + body_h / 2
+    scr_zc = body_z0 + chin + scr_h / 2
+    rbox("MonitorBody", (body_w, body_d, body_h), (0.0, 0.0, body_zc), shell, bevel=0.03)
+    rbox("MonitorRear", (body_w * 0.72, 0.16, body_h * 0.72),
+         (0.0, body_d / 2 + 0.06, body_zc + 0.02), rear, bevel=0.06)
+
+    sme = bpy.data.meshes.new("ScreenPanel")
+    bm = bmesh.new()
+    try:
+        y = -body_d / 2 - 0.002
+        q = [bm.verts.new(p) for p in ((-scr_w / 2, y, scr_zc - scr_h / 2),
+                                       (scr_w / 2, y, scr_zc - scr_h / 2),
+                                       (scr_w / 2, y, scr_zc + scr_h / 2),
+                                       (-scr_w / 2, y, scr_zc + scr_h / 2))]
+        uv = bm.loops.layers.uv.new("UVMap")
+        fc = bm.faces.new(q)
+        for li, lp in enumerate(fc.loops):
+            lp[uv].uv = ((0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 1.0))[li]
+        bm.to_mesh(sme)
+    finally:
+        bm.free()
+    smat = bpy.data.materials.new("ScreenPixels")
+    smat.use_nodes = True
+    nt = smat.node_tree
+    nt.nodes.clear()
+    out = nt.nodes.new("ShaderNodeOutputMaterial")
+    em = nt.nodes.new("ShaderNodeEmission")
+    tex = nt.nodes.new("ShaderNodeTexImage")
+    tex.image = screen_img
+    tex.interpolation = 'Closest'   # no texel blending across frame seams
+    tc = nt.nodes.new("ShaderNodeTexCoord")
+    nt.links.new(tc.outputs["UV"], tex.inputs["Vector"])
+    nt.links.new(tex.outputs["Color"], em.inputs["Color"])
+    em.inputs["Strength"].default_value = 1.0
+    nt.links.new(em.outputs["Emission"], out.inputs["Surface"])
+    sme.materials.append(smat)
+    link("ScreenPanel", sme, (0.0, 0.0, 0.0))
+
+    # chin: tally lamp and a row of backlit function keys
+    chin_z = body_z0 + chin / 2
+    front = -body_d / 2
+    rbox("TallyLamp", (0.06, 0.02, 0.022), (-body_w / 2 + 0.16, front - 0.004, chin_z),
+         tally, bevel=0.004)
+    for i in range(5):
+        rbox(f"ChinKey{i}", (0.085, 0.02, 0.03),
+             (body_w / 2 - 0.20 - i * 0.12, front - 0.004, chin_z), key, bevel=0.006)
+    rbox("ChinKeyLit", (0.085, 0.022, 0.03),
+         (body_w / 2 - 0.20, front - 0.006, chin_z), keylit, bevel=0.006)
+
+    # hood: top and flared side flaps shading the panel
+    hood_d = 0.30
+    top_z = body_z0 + body_h
+    rbox("HoodTop", (body_w + 0.04, hood_d, 0.018),
+         (0.0, front - hood_d / 2 + 0.02, top_z + 0.004), hood, bevel=0.006,
+         rot=(m.radians(-6.0), 0.0, 0.0))
+    for sx in (-1.0, 1.0):
+        rbox(f"HoodSide{'L' if sx < 0 else 'R'}", (0.018, hood_d, body_h - 0.02),
+             (sx * (body_w / 2 + 0.01) + sx * hood_d * 0.07, front - hood_d / 2 + 0.03,
+              body_zc), hood, bevel=0.006, rot=(0.0, 0.0, m.radians(-8.0 * sx)))
+
+    # yoke: foot plate, twin uprights, cross bar into the rear housing
+    rbox("YokeFoot", (0.95, 0.52, 0.05), (0.0, 0.12, riser_top + 0.025), alu, bevel=0.018)
+    for sx in (-0.26, 0.26):
+        rbox("YokeArm", (0.07, 0.07, yoke_h + 0.22),
+             (sx, 0.17, riser_top + 0.05 + (yoke_h + 0.22) / 2 - 0.01), alu, bevel=0.015)
+    rbox("YokeBar", (0.62, 0.07, 0.08), (0.0, 0.17, body_z0 + 0.20), alu, bevel=0.015)
+    for sx in (-0.26, 0.26):
+        cyl("YokeKnob", 0.055, 0.04, (sx + (0.055 if sx > 0 else -0.055), 0.17,
+                                      body_z0 + 0.20), rear,
+            rot=(0.0, m.radians(90.0), 0.0))
+
+    # control surface: a raked anodized deck with three trackballs
+    deck_rot = (m.radians(9.0), 0.0, 0.0)
+    deck_c = mathutils.Vector((0.0, -0.66, riser_top + 0.055))
+    rbox("ControlDeck", (1.55, 0.52, 0.09), tuple(deck_c), panel, bevel=0.02,
+         rot=deck_rot)
+    tilt = mathutils.Euler(deck_rot).to_matrix()
+    deck_up = tilt @ mathutils.Vector((0.0, 0.0, 1.0))
+    for i, bx in enumerate((-0.46, 0.0, 0.46)):
+        base = deck_c + tilt @ mathutils.Vector((bx, 0.04, 0.045))
+        cyl(f"TrackRing{i}", 0.15, 0.03, tuple(base + deck_up * 0.012), alu,
+            rot=deck_rot)
+        sphere(f"Trackball{i}", 0.115, tuple(base + deck_up * 0.045), ball)
+        cyl(f"TrackCollar{i}", 0.125, 0.02, tuple(base + deck_up * 0.03), key,
+            rot=deck_rot)
+    for i in range(7):
+        kx = -0.60 + i * 0.2
+        rbox(f"DeckKey{i}", (0.12, 0.06, 0.03),
+             tuple(deck_c + tilt @ mathutils.Vector((kx, -0.20, 0.05))),
+             keylit if i == 3 else key, bevel=0.008, rot=deck_rot)
+
+
+def build_stage(sc):
+    """The house dark studio: floor, wall, world, four area lights."""
+    import bmesh
+    import mathutils
     floor_me = bpy.data.meshes.new("Floor")
     bm = bmesh.new()
     try:
@@ -350,64 +498,122 @@ def render_still(sc, got, path, engine):
     fb.inputs["Roughness"].default_value = 0.7
     floor_me.materials.append(fmat)
     floor = bpy.data.objects.new("Floor", floor_me)
-    scene.collection.objects.link(floor)
+    sc.collection.objects.link(floor)
     wall = bpy.data.objects.new("Wall", floor_me.copy())
-    wall.location = (0.0, 9.0, 0.0)
+    wall.location = (0.0, 8.0, 0.0)
     wall.rotation_euler = (math.radians(90), 0.0, 0.0)
-    scene.collection.objects.link(wall)
+    sc.collection.objects.link(wall)
 
     world = bpy.data.worlds.new("World")
-    world.use_nodes = True
+    if world.node_tree is None:  # 5.x worlds ship with nodes; 4.x needs this
+        world.use_nodes = True
     world.node_tree.nodes["Background"].inputs["Color"].default_value = (0.02, 0.021, 0.025, 1.0)
-    scene.world = world
+    sc.world = world
 
     def light(name, loc, energy, size, col, target):
         ld = bpy.data.lights.new(name, 'AREA')
-        ld.energy = energy; ld.size = size; ld.color = col
+        ld.energy = energy
+        ld.size = size
+        ld.color = col
         ob = bpy.data.objects.new(name, ld)
         ob.location = loc
         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, and the signature warm
-    # 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.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 = (9.7, -17.5, 5.7)
-    scene.collection.objects.link(cam)
-    target = bpy.data.objects.new("Aim", None)
-    target.location = (0.0, 0.2, 3.2)
-    scene.collection.objects.link(target)
-    con = cam.constraints.new('TRACK_TO')
-    con.target = target
-    scene.camera = cam
-
-    scene.render.engine = 'CYCLES' if engine == 'cycles' else eevee_engine_id()
-    if engine == 'cycles':
-        scene.cycles.samples = 32
-    else:
-        try:
-            scene.eevee.taa_render_samples = 64
-        except AttributeError:
-            pass
-    scene.render.resolution_x = 1280
-    scene.render.resolution_y = 720
-    scene.render.resolution_percentage = 100
-    scene.render.image_settings.file_format = 'PNG'
-    scene.render.filepath = path
-    # Standard keeps the swatch colors true (docs/VISUAL-STYLE.md)
-    scene.view_settings.view_transform = 'Standard'
-    bpy.ops.render.render(write_still=True)
-    return os.path.exists(path) and os.path.getsize(path) > 0
+        sc.collection.objects.link(ob)
+
+    # warm shaped key upper left, faint cool fill, cool rim, and the warm
+    # wedge between console and wall raking a pool onto the backdrop
+    light("Key", (-4.0, -5.0, 6.0), 520.0, 4.5, (1.0, 0.96, 0.9), (0.0, -0.3, 0.8))
+    light("Fill", (5.5, -4.0, 2.5), 90.0, 9.0, (0.75, 0.85, 1.0), (0.0, 0.0, 1.0))
+    light("Rim", (0.5, 4.0, 5.0), 300.0, 4.0, (0.6, 0.78, 1.0), (0.0, 0.2, 1.4))
+    light("Wedge", (1.0, 3.2, 4.4), 460.0, 6.0, (1.0, 0.76, 0.5), (1.5, 8.0, 1.8))
+
+
+def render_still(sc, path, engine):
+    """Render both filmstrips from the sequencer, guard the linear reference,
+    then shoot the console with those exact pixels on its screen."""
+    tmp = tempfile.mkdtemp(prefix="vse_gamma_still_")
+    try:
+        gamma_tiles = render_filmstrip(sc, "GAMMA_CROSS", tmp)
+        linear_tiles = render_filmstrip(sc, "CROSS", tmp)
+        clear_strips(sc)
+        # the lower strip is only a fair comparison if it IS the lerp: guard
+        # the sequencer CROSS at t = 1/2 against (1-t)*A + t*B
+        k_mid = MID_FRAME - SPAN[0]
+        cy, cx = TILE_H // 2, TILE_W // 2
+        lin_mid = linear_tiles[k_mid][cy, cx, :3]
+        gam_mid = gamma_tiles[k_mid][cy, cx, :3]
+        lin_err = max(abs(float(lin_mid[k]) - naive(0.5, k)) for k in range(3))
+        gam_err = max(abs(float(gam_mid[k]) - closed_form(0.5, k)) for k in range(3))
+        print(f"filmstrip mid: gamma {tuple(round(float(v), 3) for v in gam_mid)} "
+              f"(err {gam_err:.2e}), linear {tuple(round(float(v), 3) for v in lin_mid)} "
+              f"(err {lin_err:.2e})")
+        # every frame must fill its tile edge to edge (a letterboxed COLOR
+        # strip would paint black bars into the strip and fake a dip)
+        spread = max(float((t[..., :3].max(axis=(0, 1)) - t[..., :3].min(axis=(0, 1))).max())
+                     for t in gamma_tiles + linear_tiles)
+        print(f"filmstrip frames uniform: max in-frame spread {spread:.2e}")
+        if spread > Q_TOL:
+            print(f"ERROR: a filmstrip frame is not uniform (spread {spread:.4f})",
+                  file=sys.stderr)
+            return 9
+        if lin_err > Q_TOL or gam_err > Q_TOL:
+            print(f"ERROR: filmstrip mid off its closed form (linear {lin_err:.4f}, "
+                  f"gamma {gam_err:.4f}, tol {Q_TOL}) — the comparison would lie",
+                  file=sys.stderr)
+            return 9
+
+        screen_img, aspect = compose_screen(
+            gamma_tiles, linear_tiles, os.path.join(tmp, "monitor.png"))
+        screen_img.pack()   # the raster outlives the temp dir
+
+        build_stage(sc)
+        build_console(sc, screen_img, aspect)
+
+        cam_data = bpy.data.cameras.new("Cam")
+        cam_data.lens = 50.0
+        cam = bpy.data.objects.new("Cam", cam_data)
+        cam.location = (1.55, -6.2, 1.55)
+        sc.collection.objects.link(cam)
+        aim = bpy.data.objects.new("Aim", None)
+        aim.location = (0.05, -0.2, 0.86)
+        sc.collection.objects.link(aim)
+        con = cam.constraints.new('TRACK_TO')
+        con.target = aim
+        sc.camera = cam
+
+        sc.render.engine = 'CYCLES' if engine == 'cycles' else eevee_engine_id()
+        if engine == 'cycles':
+            sc.cycles.samples = 64
+            sc.cycles.use_denoising = True
+        else:
+            try:
+                sc.eevee.taa_render_samples = 64
+            except AttributeError:
+                pass
+        sc.render.resolution_x = 1280
+        sc.render.resolution_y = 720
+        sc.render.resolution_percentage = 100
+        sc.render.image_settings.file_format = 'PNG'
+        sc.render.filepath = path
+        # Standard keeps the mounted sequencer pixels exact (docs/VISUAL-STYLE.md)
+        sc.view_settings.view_transform = 'Standard'
+
+        # Layer 1 framing gate on the console — exit 10 before the beauty pass
+        stage = [o for o in sc.objects if o.name in ("Floor", "Wall")]
+        hero = [o for o in sc.objects
+                if o.type in gallery_framing._RENDER_TYPES and o not in stage]
+        fcode = gallery_framing.check_framing(sc, cam, hero=hero, elements=hero,
+                                              stage=stage)
+        if fcode:
+            return fcode
+        bpy.ops.render.render(write_still=True)
+    finally:
+        shutil.rmtree(tmp, ignore_errors=True)
+    if not (os.path.exists(path) and os.path.getsize(path) > 0):
+        print("ERROR: render produced no file", file=sys.stderr)
+        return 8
+    return 0
 
 
 def main():
@@ -428,23 +634,9 @@ def main():
         return code
 
     if args.output:
-        # re-sample the authentic cross colors for the bench panels
-        setup_render(sc, PXW, PXH)
-        tmp = tempfile.mkdtemp(prefix="vse_gamma_still_")
-        try:
-            got = sample_colors(sc, [f for f, _t in SAMPLES], tmp)
-        finally:
-            shutil.rmtree(tmp, ignore_errors=True)
-        # the bench is a 3D scene: clear the timeline or the sequencer
-        # composites the last cross frame over everything (a full-teal
-        # still). Effects first: deleting inputs orphans-and-deletes the
-        # effect ("Strip 'GC' not in scene" otherwise)
-        coll = strips_coll(sc.sequence_editor)
-        for s in reversed(list(coll)):
-            coll.remove(s)
-        if not render_still(sc, got, os.path.abspath(args.output), args.engine):
-            print("ERROR: render produced no file", file=sys.stderr)
-            return 8
+        code = render_still(sc, os.path.abspath(args.output), args.engine)
+        if code:
+            return code
         print(f"rendered still {args.output}")
 
     print("vse-gamma-cross OK")