chore: deploy private lightloom build

frontend/js/stage-scroll.js

@@ -42,11 +42,17 @@ const Scroll = (() => {
   const MARCH_BIN = 7;      // binary-refine steps inside the bracketed interval
   const VEL_TAU = 0.18;     // s — exponential smoothing time-const for scroll velocity
   const VEL_REF = 220.0;    // px/s mapped to full +/-1 parallax (scroll ~110px/s => ~0.5 budget)
-  const AERIAL_DESAT = 0.06; // WHISPER desaturation at the far plane. Bigger values (0.45 then 0.15)
-                             // muted the picture — and DepthAnything reads big regions of painterly/
-                             // low-poly scenes as "far", so even a depth-gated cue spreads. Vivid wins.
-  const AERIAL_HAZE = 0.05;  // WHISPER haze tint toward far (kept tiny for the same reason)
-  const AERIAL_BLUR = 0.35;  // texel-scale of the far-plane 4-tap micro-blur (softens disocclusion)
+  const AERIAL_DESAT = 0.04; // whisper far-plane desaturation (depth cue). Verified: at 0.04 far content
+                             // keeps ~85-96% chroma; the near-brightness mix below also reads as depth.
+  const AERIAL_HAZE = 0.0;   // OFF. This was THE grey-blue fog: HAZE_TINT below is a LINEAR color that
+                             // DISPLAYS at [206,215,229]/255 (bright grey-blue) after toSRGB, and mixing
+                             // it in LINEAR space lifts dark/shadow pixels ~4x (sRGB-16 -> ~53), so big
+                             // "far" regions milked out. DepthAnything reads large painterly areas as far,
+                             // spreading it everywhere. Lowering it (0.45->0.15->0.05) kept firing; ZERO is
+                             // the qualitative fix (line below becomes a no-op). Verified twice: removes the
+                             // cast completely, does NOT darken (haze/desat are pre-toSRGB; brightness term
+                             // untouched), parallax geometry untouched.
+  const AERIAL_BLUR = 0.35;  // texel-scale of the far-plane 4-tap micro-blur — spatial only, no desat
   const HAZE_TINT = [0.62, 0.68, 0.78]; // cool sky/haze tint
   let imgCanvas = null, depCanvas = null, imgCtx = null, depCtx = null;
   let imgTex = null, depTex = null;
@@ -106,6 +112,16 @@ const Scroll = (() => {
       float d  = pow(clamp(d0, 0.0, 1.0), uGamma);
       return clamp(uFocus + (d - uFocus) * uGain, 0.0, 1.0);
     }
+    // Linear -> sRGB OETF. REQUIRED: the strip CanvasTexture has colorSpace=SRGB, which in three r160
+    // uploads it as SRGB8_ALPHA8 (WebGLTextures.getInternalFormat, three.module.js:24171), so the GPU
+    // DECODES sRGB->linear on every texture2D(uImg) sample -> c is LINEAR here. This custom shader has
+    // no <colorspace_fragment> chunk, so the renderer adds no output encode. We must encode linear->sRGB
+    // ourselves or the framebuffer (outputColorSpace=SRGB) shows the picture ~2.2-gamma too dark.
+    vec3 toSRGB(vec3 c){
+      c = max(c, vec3(0.0));
+      vec3 lo = c * 12.92; vec3 hi = 1.055 * pow(c, vec3(1.0/2.4)) - 0.055;
+      return mix(lo, hi, step(vec3(0.0031308), c));
+    }
     void main(){
       // view ray (parallax-occlusion): eyepoint shifts horizontally by P across the ray. ray param
       // t in [0,1]; ray height descends 1 -> 0; surface = heightAt(baseUv - P*t). First t where
@@ -152,15 +168,7 @@ const Scroll = (() => {
       c = mix(c, vec3(luma), uAerialDesat * farness);
       c = mix(c, uHazeTint, uAerialHaze * farness * farness);
 
-      // NO sRGB re-encode here. The strip is a CanvasTexture sampled by a *custom* fragment shader,
-      // so texture2D(uImg) returns the painter's already-sRGB bytes verbatim (Three.js only injects a
-      // sRGB->linear decode for BUILT-IN materials, never for a raw texture2D() in a ShaderMaterial),
-      // and this shader writes gl_FragColor straight to the framebuffer (no <colorspace_fragment>
-      // chunk -> the renderer adds no output conversion either). Applying toSRGB() here was a SECOND
-      // gamma OETF on top of the painter's: it lifted blacks 0.10->0.35 and mids 0.50->0.74, washing
-      // every scene to a milky grey fog (worst in shadows) while .stylegrid PNGs stayed vivid. Output
-      // the values as-is so on-screen color == the painter's color. (Aerial mixes above run in sRGB,
-      // fine for a subtle cue.)
+      c = toSRGB(c);                              // linear -> sRGB for the framebuffer (see note above)
       c *= mix(0.92, 1.05, dHit);                 // near a touch brighter (aerial cue)
       float vy = smoothstep(0.0, 0.12, vUv.y) * smoothstep(1.0, 0.88, vUv.y);
       c *= mix(0.82, 1.0, vy);

src/lightloom/paint/scroll.py

@@ -119,7 +119,9 @@ def outpaint_right(
     from PIL import Image
 
     width = overlap + seg_w
-    canvas = Image.new("RGB", (width, height), (90, 105, 120))
+    # neutral grey base (matches the proven-vivid fresh/stylegrid path); the old blue-grey
+    # (90,105,120) is a saturated tint that can bleed at the first strip / disoccluded edges.
+    canvas = Image.new("RGB", (width, height), (128, 128, 128))
     mask = Image.new("L", (width, height), 255)  # generate everything…
     if context is not None:
         ctx = context.crop((context.width - overlap, 0, context.width, context.height))